DevOps

Como usar o Kubernetes para orquestrar containers em um ambiente DevOps

Virgílio Borges

• 9 min read
Como usar o Kubernetes para orquestrar containers em um ambiente DevOps

O Kubernetes é uma plataforma de código aberto que permite automatizar a implantação, o dimensionamento e o gerenciamento de aplicações em containers. Neste artigo, vamos explicar o que são containers, por que eles são úteis para o desenvolvimento de software, como o Kubernetes funciona e como ele pode facilitar a integração e a entrega contínuas (CI/CD) em um ambiente DevOps.

O que são containers e por que usá-los?

Containers são unidades de software que empacotam o código e todas as suas dependências, permitindo que as aplicações sejam executadas de forma isolada e consistente em qualquer ambiente. Eles são diferentes das máquinas virtuais (VMs), que requerem um sistema operacional (SO) completo para cada aplicação. Os containers compartilham o mesmo SO do host, o que reduz o consumo de recursos e aumenta a performance.

Os containers oferecem diversas vantagens para o desenvolvimento de software, tais como:

  • Portabilidade: os containers podem ser facilmente movidos entre diferentes plataformas, nuvens ou locais, sem alterar o seu funcionamento.
  • Padronização: os containers seguem um formato comum, o que facilita a colaboração entre equipes e a integração com outras ferramentas.
  • Modularidade: os containers permitem dividir as aplicações em componentes menores e independentes, que podem ser atualizados, testados e implantados de forma ágil e segura.
  • Escalabilidade: os containers podem ser replicados ou removidos rapidamente, de acordo com a demanda, otimizando o uso dos recursos e a disponibilidade das aplicações.

O que é o Kubernetes e como ele funciona?

O Kubernetes é um sistema que orquestra os containers, ou seja, gerencia o seu ciclo de vida, a sua comunicação e a sua distribuição em um cluster de máquinas. Um cluster é um conjunto de nós (nodes), que podem ser físicos ou virtuais, onde os containers são executados. O Kubernetes possui uma arquitetura baseada em mestre/escravo (master/worker), onde há um ou mais nós mestres, responsáveis pelo controle do cluster, e vários nós escravos, responsáveis pela execução dos containers.

O Kubernetes utiliza alguns conceitos-chave para organizar e gerenciar os containers no cluster, tais como:

  • Pod: é a menor unidade de implantação do Kubernetes, que consiste em um ou mais containers relacionados, que compartilham o mesmo espaço de rede e armazenamento. Cada pod possui um endereço IP único no cluster e pode se comunicar com outros pods por meio de serviços.
  • Serviço: é uma abstração que define um conjunto lógico de pods e uma política de acesso a eles. Um serviço permite que os pods sejam acessados por meio de um nome ou um endereço IP estável, independente da sua localização no cluster.
  • Controlador: é um componente que monitora o estado atual do cluster e garante que ele esteja de acordo com o estado desejado, definido pelo usuário. Existem vários tipos de controladores no Kubernetes, como ReplicaSet, Deployment, StatefulSet, DaemonSet, Job e CronJob.
  • Namespace: é um mecanismo que permite isolar e agrupar recursos do cluster em diferentes contextos. Cada namespace possui um nome único no cluster e pode conter pods, serviços, controladores e outros objetos. Os namespaces permitem organizar as aplicações por projetos, equipes ou ambientes.

Como usar o Kubernetes em um ambiente DevOps?

DevOps é uma cultura que visa integrar as equipes de desenvolvimento e operações de software, buscando agilizar a entrega de valor para os clientes. Para isso, DevOps utiliza práticas como integração contínua (CI), entrega contínua (CD), infraestrutura como código (IaC), monitoramento e feedback.

O Kubernetes se encaixa perfeitamente nessa cultura, pois oferece recursos que facilitam a implantação e a gestão das aplicações em containers em qualquer ambiente. Além disso, o Kubernetes se integra com diversas ferramentas de DevOps, como Jenkins, GitLab CI/CD, Helm, Terraform, Prometheus e Grafana.

A seguir, vamos mostrar alguns exemplos de como usar o Kubernetes em um ambiente DevOps, utilizando o minikube, uma ferramenta que permite executar um cluster Kubernetes localmente, e o kubectl, uma ferramenta que permite interagir com o cluster por meio de comandos.

Criando um pod com um container

Para criar um pod com um container, podemos usar o comando kubectl run, especificando o nome do pod, a imagem do container e os argumentos opcionais. Por exemplo, para criar um pod chamado hello-pod com um container que executa o comando echo "Hello, Kubernetes!", podemos usar o seguinte comando:

> kubectl run hello-pod --image=busybox --restart=Never -- echo "Hello, Kubernetes!"

Para verificar se o pod foi criado com sucesso, podemos usar o comando kubectl get pods, que lista todos os pods do namespace atual:

> kubectl get pods
NAME        READY   STATUS      RESTARTS   AGE
hello-pod   0/1     Completed   0          10s

Para ver os logs do container dentro do pod, podemos usar o comando kubectl logs, especificando o nome do pod:

> kubectl logs hello-pod
Hello, Kubernetes!

Criando um serviço para expor um pod

Para expor um pod para acesso externo, podemos usar o comando kubectl expose, especificando o nome do pod, o tipo de serviço e a porta. Por exemplo, para criar um serviço chamado hello-service do tipo NodePort, que expõe a porta 8080 do pod hello-pod na porta 30000 do nó, podemos usar o seguinte comando:

kubectl expose pod hello-pod --name=hello-service --type=NodePort --port=8080

Para verificar se o serviço foi criado com sucesso, podemos usar o comando kubectl get services, que lista todos os serviços do namespace atual:

> kubectl get services
NAME           TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
hello-service  NodePort    10.108.147.26   <none>        8080:30000/TCP   10s
kubernetes     ClusterIP   10.96.0.1       <none>        443/TCP          5m23s

Para acessar o serviço, podemos usar o endereço IP do nó e a porta do serviço. Para obter o endereço IP do nó, podemos usar o comando minikube ip, que retorna o IP do cluster minikube:

> minikube ip
192.168.49.2

Para acessar o serviço, podemos usar o comando curl, especificando o IP do nó e a porta do serviço:

> curl http://192.168.49.2:30000
Hello, Kubernetes!

Criando um deployment para gerenciar um conjunto de pods

Para gerenciar um conjunto de pods que executam a mesma aplicação, podemos usar um deployment, que é um controlador que garante que o número de réplicas desejado esteja sempre disponível e atualizado. Para criar um deployment, podemos usar o comando kubectl create deployment, especificando o nome do deployment, a imagem do container e os argumentos opcionais. Por exemplo, para criar um deployment chamado hello-deployment com três réplicas de um container que executa uma aplicação web simples em Python, podemos usar o seguinte comando:

> kubectl create deployment hello-deployment --image=gcr.io/google-samples/hello-app:1.0 --replicas=3

Para verificar se o deployment foi criado com sucesso, podemos usar o comando kubectl get deployments, que lista todos os deployments do namespace atual:

> kubectl get deployments
NAME              READY   UP-TO-DATE   AVAILABLE   AGE
hello-deployment  3/3     3            3           10s

Para ver os pods criados pelo deployment, podemos usar o comando kubectl get pods, que lista todos os pods do namespace atual:

> kubectl get pods
NAME                               READY   STATUS    RESTARTS   AGE
hello-deployment-8579f694c-7gq8n   1/1     Running   0          10s
hello-deployment-8579f694c-d6z4x   1/1     Running   0          10s
hello-deployment-8579f694c-zl8xw   1/1     Running   0          10s

Para expor o deployment para acesso externo, podemos usar o mesmo comando kubectl expose, especificando o nome do deployment, o tipo de serviço e a porta. Por exemplo, para criar um serviço chamado hello-service do tipo LoadBalancer, que expõe a porta 8080 do deployment hello-deployment na porta 80 do balanceador de carga, podemos usar o seguinte comando:

> kubectl expose deployment hello-deployment --name=hello-service --type=LoadBalancer --port=80 --target-port=8080

Para verificar se o serviço foi criado com sucesso, podemos usar o comando kubectl get services, que lista todos os serviços do namespace atual:

> kubectl get services
NAME           TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
hello-service  LoadBalancer   10.109.14.231   <pending>     80:32369/TCP   10s
kubernetes     ClusterIP      10.96.0.1       <none>        443/TCP        10m23s

Para acessar o serviço, podemos usar o comando minikube service, que abre uma janela do navegador com o endereço IP do serviço. Por exemplo, para acessar o serviço hello-service, podemos usar o seguinte comando:

> minikube service hello-service

O navegador deve mostrar uma página com a mensagem “Hello, world!” e o nome do pod que atendeu a requisição.

Atualizando um deployment para uma nova versão da aplicação

Para atualizar um deployment para uma nova versão da aplicação, podemos usar o comando kubectl set image, especificando o nome do deployment, o nome do container e a nova imagem do container. Por exemplo, para atualizar o deployment hello-deployment para a versão 2.0 da aplicação web em Python, podemos usar o seguinte comando:

> kubectl set image deployment hello-deployment hello-app=gcr.io/google-samples/hello-app:2.0

Para verificar se o deployment foi atualizado com sucesso, podemos usar o comando kubectl rollout status, que mostra o progresso da atualização:

> kubectl rollout status deployment hello-deployment
Waiting for deployment "hello-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "hello-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "hello-deployment" rollout to finish: 1 old replicas are pending termination...
Waiting for deployment "hello-deployment" rollout to finish: 2 old replicas are pending termination...
Waiting for deployment "hello-deployment" rollout to finish: 3 of 3 updated replicas are available...
deployment "hello-deployment" successfully rolled out

Para ver a nova versão da aplicação, podemos acessar novamente o serviço hello-service com o comando minikube service:

> minikube service hello-service

O navegador deve mostrar uma página com a mensagem “Hello, Kubernetes!” e o nome do pod que atendeu a requisição.

Manifestos

Um manifesto Kubernetes é um arquivo YAML ou JSON que define um ou mais recursos do Kubernetes, como pods, serviços, deployments, configmaps, secrets, etc. Um manifesto Kubernetes especifica o estado desejado do recurso, como o número de réplicas, a imagem do container, os parâmetros de configuração, etc. O Kubernetes usa o manifesto para criar e gerenciar o recurso no cluster.

Aqui estão alguns exemplos de manifestos Kubernetes:

  • Um manifesto que cria um pod com um container que executa o comando echo "Hello, world!":

apiVersion: v1
kind: Pod
metadata:
  name: hello-pod
spec:
  containers:
  - name: hello-container
    image: busybox
    command: ["echo", "Hello, world!"]

  • Um manifesto que cria um serviço do tipo NodePort que expõe a porta 80 do pod hello-pod na porta 30000 do nó:

apiVersion: v1
kind: Service
metadata:
  name: hello-service
spec:
  type: NodePort
  selector:
    app: hello-pod
  ports:
  - protocol: TCP
    port: 80
    nodePort: 30000

  • Um manifesto que cria um deployment que gerencia três réplicas de um pod que executa uma aplicação web em Python:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-pod
  template:
    metadata:
      labels:
        app: web-pod
    spec:
      containers:
      - name: web-container
        image: gcr.io/google-samples/hello-app:1.0
        ports:
        - containerPort: 8080

Você pode encontrar mais exemplos de manifestos Kubernetes na documentação oficial (https://www.digitalocean.com/community/cheatsheets/getting-started-with-kubernetes-a-kubectl-cheat-sheet-pt) ou em sites de referência (https://learn.microsoft.com/pt-br/azure/devops/pipelines/tasks/reference/kubernetes-manifest-v0?view=azure-pipelines).

Conclusão

Neste artigo, vimos como usar o Kubernetes para orquestrar containers em um ambiente DevOps. Aprendemos o que são containers e por que eles são úteis para o desenvolvimento de software, como o Kubernetes funciona e como ele pode facilitar a integração e a entrega contínuas (CI/CD) em um ambiente DevOps. Vimos também alguns exemplos de como criar e gerenciar pods, serviços e deployments com o Kubernetes, usando o minikube e o kubectl.

O Kubernetes é uma ferramenta poderosa e flexível que permite automatizar a implantação, o dimensionamento e o gerenciamento de aplicações em containers em qualquer ambiente. Ele se integra com diversas ferramentas de DevOps, como Jenkins, GitLab CI/CD, Helm, Terraform, Prometheus e Grafana. Com o Kubernetes, é possível criar aplicações mais portáteis, padronizadas, modulares e escaláveis.

Referências Bibliográficas:

  • Kubernetes Documentation - https://kubernetes.io/docs/home/
  • What is Kubernetes? - https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/
  • What is a Container? - https://www.docker.com/resources/what-container
  • Kubernetes Concepts - https://kubernetes.io/docs/concepts/
  • Kubernetes Tutorials - https://kubernetes.io/docs/tutorials/
  • Minikube - https://minikube.sigs.k8s.io/docs/start/
  • Kubectl Cheat Sheet - https://kubernetes.io/docs/reference/kubectl/cheatsheet/

💡
As opiniões e comentários expressos neste artigo são de propriedade exclusiva de seu autor e não representam necessariamente o ponto de vista da Revelo.

A Revelo Content Network acolhe todas as raças, etnias, nacionalidades, credos, gêneros, orientações, pontos de vista e ideologias, desde que promovam diversidade, equidade, inclusão e crescimento na carreira dos profissionais de tecnologia.