> ## Documentation Index
> Fetch the complete documentation index at: https://ayakaleaf-pro.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# 0. Preparar os nós

> Instale o Docker Engine, o containerd e o kubeadm nos nós e baixe as imagens do TeX Live.

O Ayakaleaf Pro compila LaTeX em contêineres do TeX Live [em sandbox](https://ayakaleaf-pro.mintlify.site/pt/on-premises/configuration/overleaf-toolkit/sandboxed-compiles.md). Ele mesmo os inicia, por meio do socket do Docker da máquina em que é executado. No Kubernetes, isso significa que:

* cada nó que pode executar o pod do Ayakaleaf Pro tem o **Docker Engine** instalado e em execução;
* cada imagem do TeX Live que você configurar é baixada **no Docker** de cada um desses nós.

O kubelet pode continuar usando o containerd: o Docker Engine inclui o `containerd.io`, e ambos usam o mesmo daemon em namespaces diferentes.

> [!WARNING]
>
> Pools de nós gerenciados sem Docker (a maioria dos padrões do EKS, GKE e AKS) não conseguem executar Sandboxed Compiles. Use pools de nós em que você possa instalar o Docker Engine, ou rotule esses nós e mantenha o Ayakaleaf Pro neles com um `nodeSelector`.

As etapas abaixo são para o Ubuntu 24.04 e um cluster criado com o kubeadm. Se o seu cluster já existir, execute as etapas 1, 2 e 5 nos nós que executarão o Ayakaleaf Pro.

**1. Módulos do kernel e sysctls**

```bash theme={null}
printf 'overlay\nbr_netfilter\n' | sudo tee /etc/modules-load.d/k8s.conf
sudo modprobe overlay && sudo modprobe br_netfilter
printf 'net.bridge.bridge-nf-call-iptables=1\nnet.bridge.bridge-nf-call-ip6tables=1\nnet.ipv4.ip_forward=1\n' \
  | sudo tee /etc/sysctl.d/99-k8s.conf
sudo sysctl --system
sudo swapoff -a   # and comment out swap in /etc/fstab
```

**2. Docker Engine**

Instale o Docker Engine a partir do repositório do Docker, como em [0. Configurar o Docker](https://ayakaleaf-pro.mintlify.site/pt/on-premises/installation/using-the-toolkit/0.-setup-docker.md). O plugin Compose não é necessário. Isso também instala o `containerd.io`.

**3. containerd para o kubelet**

O pacote `containerd.io` do repositório do Docker vem com o plugin CRI desativado. Grave a configuração padrão completa, que o ativa, e mude-a para cgroups do systemd:

```bash wrap theme={null}
containerd config default | sudo tee /etc/containerd/config.toml >/dev/null
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
# containerd 2.x writes config_path = '' and ignores /etc/containerd/certs.d without this
sudo sed -i "s|config_path = ''|config_path = '/etc/containerd/certs.d'|" /etc/containerd/config.toml
sudo systemctl restart containerd docker
```

**4. kubeadm, kubelet e kubectl**

Siga [Installing kubeadm](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/) e, em seguida, crie o cluster com `kubeadm init` e `kubeadm join` e instale um plugin de rede. Por exemplo, com o flannel:

```yaml title="kubeadm-config.yaml" theme={null}
apiVersion: kubeadm.k8s.io/v1beta4
kind: ClusterConfiguration
networking:
  podSubnet: 10.244.0.0/16   # flannel's default
---
apiVersion: kubelet.config.k8s.io/v1beta1
kind: KubeletConfiguration
cgroupDriver: systemd
# Compile containers are started by Docker, outside the kubelet's accounting: keep memory for them
systemReserved:
  memory: 300Mi
kubeReserved:
  memory: 200Mi
```

```bash theme={null}
sudo kubeadm init --config kubeadm-config.yaml
kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml
```

O cluster também precisa de uma StorageClass padrão. Para um cluster de teste, o [local-path-provisioner](https://github.com/rancher/local-path-provisioner) funciona; em produção, use o armazenamento em bloco da sua plataforma (Longhorn, Ceph, um driver CSI de nuvem).

**5. Imagens do TeX Live**

Em **cada** nó que pode executar o Ayakaleaf Pro, baixe com o Docker as imagens do TeX Live que você vai listar em `ALL_TEX_LIVE_DOCKER_IMAGES`, por exemplo:

```bash theme={null}
sudo docker pull ghcr.io/ayaka-notes/texlive-full:2026.1
```

`crictl pull` ou `ctr` não ajudam aqui: o Ayakaleaf Pro pede a imagem ao Docker. As imagens completas são grandes (cerca de 28 GB cada); veja [Sandboxed Compiles](https://ayakaleaf-pro.mintlify.site/pt/on-premises/configuration/overleaf-toolkit/sandboxed-compiles.md) para a lista. Para um primeiro teste, `ghcr.io/ayaka-notes/texlive-basic:2026.1` (cerca de 630 MB, um TeX Live mínimo) é suficiente.

### Q\&A

> [accordion] Posso executar o Ayakaleaf Pro em nós sem Docker?
>
> **Resposta:** Somente com `SANDBOXED_COMPILES=false`. As compilações passam então a ser executadas dentro do contêiner do Ayakaleaf Pro com seu pequeno TeX Live embutido, e os documentos LaTeX podem ler e gravar tudo o que esse contêiner pode. Não recomendamos isso; veja [Sandboxed Compiles](https://ayakaleaf-pro.mintlify.site/pt/on-premises/configuration/overleaf-toolkit/sandboxed-compiles.md).

> [accordion] As compilações contam para o limite de memória do pod?
>
> **Resposta:** Não. Os contêineres do TeX Live são iniciados pelo Docker do nó, fora do pod e fora da visão do kubelet. Deixe memória livre no nó para eles, por exemplo com `systemReserved` como acima, e não encha o nó com outros pods.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.