CRI-O como substituto do Docker como ambiente de execução para Kubernetes: configuração no CentOS 8

Olá! Meu nome é Sergey, sou DevOps no Surf. O departamento DevOps da Surf pretende não só estabelecer interação entre especialistas e integrar processos de trabalho, mas também pesquisar e implementar ativamente tecnologias atuais tanto na sua própria infraestrutura como na infraestrutura do cliente.

A seguir falarei um pouco sobre as mudanças na pilha de tecnologia para containers que encontramos ao estudar a distribuição 8 CentOS e o que é CRI-O e como configurar rapidamente um ambiente executável para Kubernetes.

Por que o Docker não está incluído no CentOS 8?

Depois de instalar as versões principais mais recentes RHEL 8 ou 8 CentOS não podemos deixar de notar: essas distribuições e repositórios oficiais não contêm o aplicativo Estivador, que substituem ideológica e funcionalmente os pacotes Podman, Construir (presente na distribuição por padrão) e CRI-O. Isto se deve à implementação prática de padrões desenvolvidos, entre outras coisas, pela Red Hat como parte do projeto Open Container Initiative (OCI).

O objetivo da OCI, que faz parte da Linux Foundation, é criar padrões abertos da indústria para formatos de contêineres e tempos de execução que resolvam vários problemas ao mesmo tempo. Em primeiro lugar, não contradiziam a filosofia do Linux (por exemplo, na parte que cada programa deveria realizar uma ação, e Estivador é uma espécie de combinação tudo-em-um). Em segundo lugar, poderiam eliminar todas as deficiências existentes no software Estivador. Terceiro, eles seriam totalmente compatíveis com os requisitos de negócios das principais plataformas comerciais para implantação, gerenciamento e atendimento de aplicações em contêineres (por exemplo, Red Hat OpenShift).

Contras: Estivador e as vantagens do novo software já foram descritas com algum detalhe em Este artigo, e uma descrição detalhada de toda a pilha de software oferecida no projeto OCI e seus recursos de arquitetura podem ser encontrados na documentação oficial e nos artigos da própria Red Hat (nada mal artigo no blog da Red Hat) e em terceiros avaliações.

É importante observar quais funcionalidades os componentes da pilha proposta possuem:

• Podman — interação direta com contêineres e armazenamento de imagens por meio do processo runC;
• Construir — montagem e upload de imagens para o registro;
• CRI-O — um ambiente executável para sistemas de orquestração de contêineres (por exemplo, Kubernetes).

Acho que para entender o esquema geral de interação entre os componentes da pilha, é aconselhável fornecer aqui um diagrama de conexão Kubernetes c correr C e bibliotecas de baixo nível usando CRI-O:

CRI-O и Kubernetes aderir ao mesmo ciclo de lançamento e suporte (a matriz de compatibilidade é muito simples: versões principais Kubernetes и CRI-O coincidem), e isso, levando em consideração o foco em testes completos e abrangentes da operação desta pilha pelos desenvolvedores, nos dá o direito de esperar a máxima estabilidade alcançável na operação em quaisquer cenários de uso (a leveza relativa também é benéfica aqui CRI-O comparado a Estivador devido à limitação proposital de funcionalidade).

Ao instalar Kubernetes "caminho certo" (de acordo com a OCI, é claro) usando CRI-O em 8 CentOS Encontramos algumas pequenas dificuldades, que, no entanto, superamos com sucesso. Terei prazer em compartilhar com vocês as instruções de instalação e configuração, que no total levarão cerca de 10 minutos.

Como implantar Kubernetes no CentOS 8 usando a estrutura CRI-O

Pré-requisitos: presença de pelo menos um host (2 núcleos, 4 GB de RAM, pelo menos 15 GB de armazenamento) com instalação 8 CentOS (o perfil de instalação “Servidor” é recomendado), bem como entradas para ele no DNS local (como último recurso, você pode usar uma entrada em /etc/hosts). E não se esqueça desabilitar troca.

Realizamos todas as operações no host como usuário root, tome cuidado.

1. Na primeira etapa iremos configurar o SO, instalar e configurar dependências preliminares para CRI-O.
   • Vamos atualizar o sistema operacional:

     dnf -y update
     

   • Em seguida você precisa configurar o firewall e o SELinux. Aqui tudo depende do ambiente em que nosso host ou hosts irão trabalhar. Você pode configurar um firewall de acordo com as recomendações do documentaçãoou, se você estiver em uma rede confiável ou usar um firewall de terceiros, altere a zona padrão para confiável ou desative o firewall:

     firewall-cmd --set-default-zone trusted
     
     firewall-cmd --reload

     Para desligar o firewall você pode usar o seguinte comando:

     systemctl disable --now firewalld
     

     O SELinux precisa ser desligado ou colocado no modo “permissivo”:

     setenforce 0
     
     sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

   • Carregue os módulos e pacotes necessários do kernel, configure o carregamento automático do módulo “br_netfilter” na inicialização do sistema:

     modprobe overlay
     
     modprobe br_netfilter
     
     echo "br_netfilter" >> /etc/modules-load.d/br_netfilter.conf
     
     dnf -y install iproute-tc
     

   • Para ativar o encaminhamento de pacotes e corrigir o processamento do tráfego, faremos as configurações apropriadas:

     cat > /etc/sysctl.d/99-kubernetes-cri.conf <<EOF
     net.bridge.bridge-nf-call-iptables = 1
     net.ipv4.ip_forward = 1
     net.bridge.bridge-nf-call-ip6tables = 1
     EOF
     

     aplique as configurações feitas:

     sysctl --system

   • defina a versão necessária CRI-O (versão principal CRI-O, como já mencionado, corresponda à versão necessária Kubernetes), desde a última versão estável Kubernetes atualmente 1.18:

     export REQUIRED_VERSION=1.18
     

     adicione os repositórios necessários:

     dnf -y install 'dnf-command(copr)'
     
     dnf -y copr enable rhcontainerbot/container-selinux
     
     curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable.repo https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable/CentOS_8/devel:kubic:libcontainers:stable.repo
     
     curl -L -o /etc/yum.repos.d/devel:kubic:libcontainers:stable:cri-o:$REQUIRED_VERSION.repo https://download.opensuse.org/repositories/devel:kubic:libcontainers:stable:cri-o:$REQUIRED_VERSION/CentOS_8/devel:kubic:libcontainers:stable:cri-o:$REQUIRED_VERSION.repo

   • agora podemos instalar CRI-O:

     dnf -y install cri-o
     

     Preste atenção na primeira nuance que encontramos durante o processo de instalação: você precisa editar a configuração CRI-O antes de iniciar o serviço, pois o componente conmon necessário possui um local diferente daquele especificado:

     sed -i 's//usr/libexec/crio/conmon//usr/bin/conmon/' /etc/crio/crio.conf

     Agora você pode ativar e iniciar o daemon CRI-O:

     systemctl enable --now crio
     

     Você pode verificar o status do daemon:

     systemctl status crio
     

2. Instalação e ativação Kubernetes.
   • Vamos adicionar o repositório necessário:

     cat <<EOF > /etc/yum.repos.d/kubernetes.repo
     [kubernetes]
     name=Kubernetes
     baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-$basearch
     enabled=1
     gpgcheck=1
     repo_gpgcheck=1
     gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
     exclude=kubelet kubeadm kubectl
     EOF
     

     Agora podemos instalar Kubernetes (versão 1.18, conforme mencionado acima):

     dnf install -y kubelet-1.18* kubeadm-1.18* kubectl-1.18* --disableexcludes=kubernetes

   • A segunda nuance importante: já que não usamos um daemon Estivador, mas usamos o daemon CRI-O, antes do lançamento e inicialização Kubernetes você precisa fazer as configurações apropriadas no arquivo de configuração /var/lib/kubelet/config.yaml, tendo primeiro criado o diretório desejado:

     mkdir /var/lib/kubelet
     
     cat <<EOF > /var/lib/kubelet/config.yaml
     apiVersion: kubelet.config.k8s.io/v1beta1
     kind: KubeletConfiguration
     cgroupDriver: systemd
     EOF

   • O terceiro ponto importante que encontramos durante a instalação: apesar de termos indicado o driver utilizado cgrupo, e sua configuração através dos argumentos passados cubeta está desatualizado (como está explicitamente indicado na documentação), precisamos adicionar argumentos ao arquivo, caso contrário nosso cluster não será inicializado:

     cat /dev/null > /etc/sysconfig/kubelet
     
     cat <<EOF > /etc/sysconfig/kubelet
     KUBELET_EXTRA_ARGS=--container-runtime=remote --cgroup-driver=systemd --container-runtime-endpoint='unix:///var/run/crio/crio.sock'
     EOF

   • Agora podemos ativar o daemon cubeta:

     sudo systemctl enable --now kubelet
     

     Para customizar avião de controle ou trabalhador nós em minutos, você pode usar com este roteiro.

3. É hora de inicializar nosso cluster.
   • Para inicializar o cluster, execute o comando:

     kubeadm init --pod-network-cidr=10.244.0.0/16
     

     Certifique-se de anotar o comando para ingressar no cluster “kubeadm join…”, que você deverá usar no final da saída, ou pelo menos os tokens especificados.

   • Vamos instalar o plugin (CNI) para a rede Pod. Eu recomendo usar Chita. Possivelmente mais popular Flanela tem problemas de compatibilidade com nftables, e Chita - a única implementação CNI recomendada e totalmente testada pelo projeto Kubernetes:

     kubectl --kubeconfig /etc/kubernetes/admin.conf apply -f https://docs.projectcalico.org/v3.15/manifests/calico.yaml 

   • Para conectar um nó de trabalho ao nosso cluster, você precisa configurá-lo de acordo com as instruções 1 e 2 ou usar roteiroe execute o comando da saída “kubeadm init...” que anotamos na etapa anterior:

     kubeadm join $CONTROL_PLANE_ADDRESS:6443 --token $TOKEN 
         --discovery-token-ca-cert-hash $TOKEN_HASH

   • Vamos verificar se nosso cluster foi inicializado e começou a funcionar:

     kubectl --kubeconfig=/etc/kubernetes/admin.conf get pods -A
     

   Preparar! Você já pode hospedar cargas em seu cluster K8s.

O que nos espera pela frente

Espero que as instruções acima tenham ajudado a poupar algum tempo e nervosismo.
O resultado dos processos que ocorrem na indústria muitas vezes depende de como eles são aceitos pela maior parte dos usuários finais e desenvolvedores de outros softwares no nicho correspondente. Ainda não está totalmente claro aonde as iniciativas da OCI levarão dentro de alguns anos, mas estaremos observando com prazer. Você pode compartilhar sua opinião agora mesmo nos comentários.

Esteja atento

Este artigo apareceu graças às seguintes fontes:

• Seção sobre tempos de execução de contêiner Documentação do Kubernetes
• Página Projeto CRI-O na Internet
• Artigos do blog da Red Hat: este, este e muitos outros

Fonte: habr.com