Clever Geek Handbook

Acelere o pipeline de CI / CD com Kubernetes no Docker (KinD)

Em nosso novo artigo traduzido, entendemos KinD com um exemplo prático.


Criar um cluster Kubernetes está ficando mais fácil com o tempo. Existem várias soluções chave na mão disponíveis no mercado, e agora ninguém escolhe o caminho difícil!







É importante notar que o Minikube foi um dos principais clusters que os desenvolvedores usaram para desenvolver e testar contêineres rapidamente. Embora o Minikube atualmente suporte o clustering multisite em uma base experimental, ele ainda não está disponível no General Access (GA).



Consequentemente, isso limita a capacidade de integrar e testar componentes, e é por isso que a maioria das organizações usa os serviços de nuvem gerenciados do Kubernetes para isso.

Para integrar o Kubernetes ao pipeline de CI / CD (integração e implantação contínua) e realizar testes, você precisa das seguintes ferramentas: Terraform, dependendo do provedor de nuvem e, claro, uma ferramenta de CI / CD como Jenkins, GitLab ou GitHub.



Para grandes empresas com orçamentos suficientes, essas são boas opções, mas os desenvolvedores geralmente procuram algo que os ajude a começar rapidamente. A implantação de um cluster Kubernetes na nuvem também leva algum tempo (cerca de 10 minutos), o que pode ser um obstáculo para os CIs que precisam obter assemblies rapidamente.

Kubernetes in Docker ou KinD é uma implementação da abordagem Docker-in-Docker (DinD) para Kubernetes. Essa ferramenta cria contêineres que atuam como hosts Kubernetes e você só precisa instalar o Docker em sua máquina.



Ele permite que você implante um cluster de vários nós em alguns minutos, sem depender de outras ferramentas ou provedores de nuvem. Isso o torna útil não apenas para o desenvolvimento local, mas também para CI / CD.



Arquitetura KinD



O Kubernetes no Docker usa a abordagem Docker-in-Docker (DinD) para executar um cluster do Kubernetes. Ele executa vários contêineres do Docker que funcionam como hosts Kubernetes. Os contêineres do Docker montam um volume docker.sock no Docker em execução em sua máquina para se comunicar com o tempo de execução do contêiner subjacente.







KinD foi testado para conformidade e obteve a certificação CNCF. Ele usa o Kubeadm para inicializar o cluster e também gera arquivos de configuração do Kube para o usuário por meio do qual você gerencia o cluster, permitindo que você use o kubectl para interagir com os clusters. Outros componentes do Kubernetes, como Helm e Istio, também funcionam muito bem em clusters KinD.



A desvantagem do KinD é que ele não funciona com os serviços LoadBalancer , então você terá que usar o NodePort para encaminhar seus serviços externamente.



Além disso, DinD não é atualmente a solução mais segura, então use clusters KinD apenas em máquinas de desenvolvimento local e pipelines de CI / CD. Nunca use o KinD em um ambiente de produção!



Instalando KinD



KinD consiste em um utilitário de linha de comando simples que você pode baixar e colocar em seu caminho. Então você pode interagir com KinD usando os comandos kind : 



sudo curl -sL https://kind.sigs.k8s.io/dl/v0.9.0/kind-linux-amd64 -o /usr/local/bin/kind
sudo chmod +x /usr/local/bin//kind


Em seguida, você pode criar seu cluster usando o seguinte comando: 



kind create cluster --wait 10m




Este comando criará um cluster de nó único. Mas se você quiser definir um cluster de vários nós, pode usar um arquivo de configuração de cluster semelhante ao que está abaixo: 



# three node (two workers) cluster config
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker


Em seguida, crie um cluster com um arquivo de configuração usando o seguinte comando: 



kind create cluster --wait 10m --config kind-config.yaml


Você também pode criar clusters com vários níveis de gerenciamento, especificando várias funções na seção de nós.



Como o KinD cria automaticamente um arquivo de configuração Kube, você pode usar os comandos kubectl da mesma forma que faria com outros clusters.



Remover um cluster KinD também é fácil. Execute o seguinte comando: 



kind delete cluster


Começando



Sem mais delongas, vamos descobrir na prática como o pipeline de CI / CD usa o KinD. Usaremos o GitHub Actions como nossa ferramenta de CI / CD porque é fácil de usar, não requer nenhuma infraestrutura adicional e pode ser executado por qualquer pessoa com um laptop e uma conexão à Internet.



Vamos criar um aplicativo NGINX simples denominado "Hello World".



Realizamos as seguintes ações:



  1. Criamos uma versão dev do aplicativo.
  2. Começamos a testar os componentes do cluster KinD.
  3. Se o teste for bem-sucedido, traduzimos a imagem em liberação e a enviamos para o Docker Hub.


As condições necessárias



  • Conta GitHub
  • Conta Docker Hub


Guia rápido



  1. Bifurque este repositório neste repositório.
  2. Vá para o repositório e crie dois segredos : DOCKER_USER e DOCKER_PW . Eles devem conter seu nome de usuário e senha da conta do Docker Hub, respectivamente.
  3. Acesse Ações do GitHub e execute as tarefas novamente. Como alternativa, você pode modificar o arquivo README.md e executá-lo para acionar a ação.


Versão longa



Vamos dar uma olhada no arquivo build-pipeline.yml no GitHub Actions para entender como ele funciona: 



name: Docker Image CI

on: [push]
     # Environment variables available to all jobs and steps in this workflow
env: # Or as an environment variable
      docker_username: ${{ secrets.DOCKER_USER }}
      docker_password: ${{ secrets.DOCKER_PW }}

jobs:

  build-docker-image:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
      with:
        fetch-depth: 0
    - name: Build the Docker image
      run: docker build -t $docker_username/nginx:dev .
    - name: Login to Docker
      run: echo "$docker_password" | docker login -u "$docker_username" --password-stdin
    - name: Push the docker image
      run: docker push $docker_username/nginx:dev

  kubernetes-component-test:
    runs-on: ubuntu-latest
    needs: build-docker-image
    steps:
    - uses: actions/checkout@v2
      with:
        fetch-depth: 0
    - name: Run KIND Test
      run: sudo sh build-test.sh $docker_username
  
  promote-and-push-docker-image:
    runs-on: ubuntu-latest
    needs: kubernetes-component-test
    steps:
    - uses: actions/checkout@v2
      with:
        fetch-depth: 0
    - name: Pull the Docker image
      run: docker pull $docker_username/nginx:dev
    - name: Tag the Docker image
      run: docker tag $docker_username/nginx:dev $docker_username/nginx:release
    - name: Login to Docker
      run: echo "$docker_password" | docker login -u "$docker_username" --password-stdin
    - name: Push the docker image
      run: docker push $docker_username/nginx:release


O pipeline de montagem executa três tarefas em sequência:



  1. A tarefa build-docker-image cria uma imagem Docker para desenvolvimento e a envia para o Docker Hub na construção bem-sucedida. Nesta tarefa, você pode executar seu teste de unidade.
  2. A tarefa kubernetes-component-test configura um cluster KinD e executa um teste de componente para o aplicativo.
  3. A tarefa promotion -and-push-docker-image puxa a imagem de desenvolvimento, marca-a para liberar e envia a liberação para o Docker Hub.


Vamos dar uma olhada no Dockerfile para entender o que ele cria: 



FROM nginx
RUN echo 'Hello World' > /usr/share/nginx/html/index.html


A segunda etapa é a chave, ele executa o script build-test.sh . Agora vamos dar uma olhada no script: 



#! /bin/bash
docker_username=$1
set -xe
curl -sL https://kind.sigs.k8s.io/dl/v0.9.0/kind-linux-amd64 -o /usr/local/bin/kind
chmod 755 /usr/local/bin//kind
curl -sL https://storage.googleapis.com/kubernetes-release/release/v1.17.4/bin/linux/amd64/kubectl -o
chmod 755 /usr/local/bin//kubectl
curl -LO https://get.helm.sh/helm-v3.1.2-linux-amd64.tar.gz
tar -xzf helm-v3.1.2-linux-amd64.tar.gz
mv linux-amd64/helm /usr/local/bin/
rm -rf helm-v3.1.2-linux-amd64.tar.gz
kind version
kubectl version --client=true
helm version
kind create cluster --wait 10m --config kind-config.yaml
kubectl get nodes
docker build -t $docker_username/nginx:dev .
kind load docker-image $docker_username/nginx:dev
kubectl apply -f nginx-deployment.yaml
kubectl apply -f nginx-service.yaml
NODE_IP=$(kubectl get node -o wide|tail -1|awk {'print $6'})
NODE_PORT=$(kubectl get svc nginx-service -o go-template='{{range.spec.ports}}{{if .nodePort}}{{.node
sleep 60
SUCCESS=$(curl $NODE_IP:$NODE_PORT)
if [[ "${SUCCESS}" != "Hello World" ]];
then
 kind -q delete cluster
exit 1;
else
 kind -q delete cluster
echo "Component test succesful"
fi


O que o script faz:



  1. Faz o download e instala os utilitários kind , kubectl e helm no servidor de CI.
  2. Cria um cluster de vários nós usando o arquivo kind-config.yaml .
  3. Docker docker build.
  4. Docker KinD. KinD, Docker Hub.
  5. deployment NodePort NodePortservice.
  6. IP- , , «Hello World».
  7. , KinD, «Component test successful» ( ) . , KinD .




Quando começamos a trabalhar com um pipeline, o GitHub Actions inicia automaticamente todo o pipeline:







sem dúvida, essa é uma melhoria e uma maneira conveniente de realizar integração e implantação contínuas usando Docker e Kubernetes. O Kubernetes no Docker não apenas simplifica o desenvolvimento local, mas também é uma ótima ferramenta para CI / CD.



Obrigado por ler o artigo! Espero que tenha gostado!


More articles:


All Articles