Kubernetes Tutorial: Um guia para iniciantes na implantação de aplicativos

Kubernetes Basics: Pods, implantações, serviços e namespaces

Então, agora que configuramos um cluster e verificamos se tudo funciona, é hora de criar nosso primeiro aplicativo.

Mas antes de criar o primeiro aplicativo, é essencial que você entenda os conceitos básicos do Kubernetes. Se você quiser uma introdução mais profunda ao Kubernetes, recomendo que confira o curso Introduction to Kubernetes.

Os conceitos mais básicos do Kubernetes são Pods, Implantações e Serviços. Conhecer esses três tipos de recursos pode ajudar você a criar aplicativos poderosos. Portanto, vamos nos aprofundar nelas.

O que são pods?

Um pod é a menor unidade implantável no Kubernetes. Ele executa um ou mais contêineres fortemente acoplados com o mesmo armazenamento, rede e namespace. Um pod é sempre agendado em um nó do Kubernetes. 

Você pode definir quantos recursos seu POD deve obter (por exemplo, CPU e memória). 

Um exemplo de aplicativo com dois contêineres poderia ser o seu contêiner de aplicativo e um contêiner auxiliar que agrega os logs e os envia para algum lugar. 

Características de um pod:

• Instância única: Cada pod executa uma única instância do seu aplicativo.
• Efêmero por natureza: Os pods são projetados para serem temporários e estão sendo substituídos se falharem ou forem atualizados.

Exemplo de YAML para criar um pod:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: nginx-container
    image: nginx:1.21
    ports:
    - containerPort: 80

Em seguida, você pode instalar o pod usando o kubectl:

kubectl apply -f pod.yaml

Isso iniciaria um pod chamado my-pod, executando um servidor da Web nginx para você.

O que são implantações?

Uma implantação é um objeto de nível superior do Kubernetes usado para gerenciar o ciclo de vida dos pods. Ele garante que o número desejado de réplicas de pod esteja em execução e lida com atualizações e reversões. 

Recursos de uma implantação:

• Gerenciamento de réplicas: Garante que o número desejado de pods esteja sempre em execução.
• Autocura: Substitui automaticamente os Pods que não estão saudáveis.
• Atualizações contínuas: Atualiza a versão do aplicativo passo a passo sem tempo de inatividade (se configurado).

Vejamos como seria um arquivo YAML de implantação que cria novamente um servidor da Web nginx, mas desta vez com três réplicas:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80

Você pode instalar essa implantação com o kubectl:

kubectl apply -f deployment.yaml

O procedimento acima criaria um Deployment chamado nginx-deployment que cria três Pods, cada um executando o contêiner nginx. 

O que são serviços?

Agora vamos para a última parte: Os serviços. 

Um serviço é uma abstração que fornece acesso de rede estável aos pods, mesmo que seus endereços IP mudem. Ele funciona como uma ponte entre seus aplicativos e clientes externos. 

Mas por que isso é necessário? Cada pod tem seu próprio endereço IP. Então, por que não podemos usar diretamente esse endereço IP? 

Nós podemos! Mas não deveríamos. Por quê? 

Como um pod é efêmero, ele é eliminado pela implantação e um novo pod é dimensionado sempre que o pod não está saudável. Esse novo pod tem um endereço IP diferente. Isso significaria que o cliente que deseja usar o seu aplicativo teria que alterar permanentemente o endereço IP sempre que um pod falhasse, o que pode acontecer com frequência.

É aqui que um serviço entra em ação: ele procura todos os pods que correspondem a um rótulo específico e encaminha automaticamente o tráfego para eles. Se um pod ficar insalubre, o serviço deixará de enviar tráfego para esse pod. E se um novo pod for criado, ele começará a enviar tráfego para o novo pod. 

O serviço também distribui o tráfego entre todas as réplicas da sua implantação, o que é fantástico, pois isso significa que você pode criar mais instâncias do seu aplicativo para distribuir o tráfego sem precisar gerenciar isso por meio da lógica do aplicativo.

Tipos de serviços:

• ClusterIP (padrão): Expõe o serviço dentro do cluster.
• NodePort: Expõe o serviço em uma porta acessível fora do cluster.
• LoadBalancer: Integra-se com provedores de nuvem para expor o serviço por meio de um balanceador de carga.

Exemplo de YAML para expor nosso servidor da Web nginx para fora do cluster:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

Você pode criar novamente esse serviço usando o kubectl:

kubectl apply -f service.yaml

Esse serviço agora distribuiria o tráfego de entrada para todos os pods com o rótulo app=nginx na porta 80. 

Se você executar um comando describe no serviço recém-criado, verá que agora há três pontos de extremidade, em que cada ponto de extremidade representa o endereço IP do pod que está em execução no momento:

kubectl describe service nginx-service

O comando acima deve retornar algo semelhante a: 

Name:                     nginx-service
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=nginx
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.104.53.131
IPs:                      10.104.53.131
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  32256/TCP
Endpoints:                10.244.0.5:80,10.244.0.6:80,10.244.0.7:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

Relacionamentos entre pods, implantações e serviços

Então, para resumir rapidamente:

• Pods: Representam instâncias individuais de aplicativos.
• Implantações: Gerencie o ciclo de vida dos pods e garanta que eles estejam saudáveis.
• Serviços: Forneça acesso estável aos pods e permita a comunicação externa ou interna.

O que são Namespaces?

Os namespaces no Kubernetes permitem que você organize e isole recursos em um cluster. Você pode pensar neles como clusters virtuais dentro do mesmo cluster físico. 

Benefícios do uso de Namespaces:

• Separação de preocupações: Diferentes equipes ou aplicativos podem operar em seu próprio namespace sem afetar os outros. 
• Gerenciamento de recursos: Você pode definir cotas e limites de recursos para diferentes namespaces.
• Segurança e controle de acesso: As políticas podem ser aplicadas no nível do namespace.

Por padrão, o Kubernetes vem com alguns namespaces incorporados:

• padrão: Os namespaces padrão em que os recursos são criados, a menos que especificado de outra forma
• kube-system: Usado para componentes internos do Kubernetes (por exemplo, servidor de API, agendador etc.).
• kube-public: Um namespace publicamente legível.
• kube-node-lease: Usado para rastrear os batimentos cardíacos do nó.

Você pode criar um namespace usando um arquivo YAML: 

apiVersion: v1
kind: Namespace
metadata:
  name: my-namespace

Salve isso em um arquivo chamado namespace.yaml e aplique-o usando: 

kubectl apply -f namespace.yaml

Ao executar o comando abaixo, você verá uma lista de todos os namespaces padrão listados e o recém-criado: 

kubectl get namespaces

Você pode então criar recursos nesse namespace simplesmente definindo o namespace na seção de metadados do seu recurso. 

Nossa implantação do nginx seria parecida com a seguinte se você quiser criá-la no namespace recém-criado:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: my-namespace
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80

Agora, você precisa declarar explicitamente que deseja recuperar recursos do seu namespace recém-criado usando oargumento -n :

kubectl get deployment -n my-namespace

Gerenciando seu primeiro aplicativo com o Kubernetes

Agora que você está familiarizado com os conceitos básicos do Kubernetes, é hora de implantar nosso primeiro aplicativo Web no Kubernetes e tentar acessá-lo. 

Neste capítulo, criaremos um servidor da Web nginx, exporemos esse servidor da Web por meio de um serviço ao mundo externo, dimensionaremos esse aplicativo para simular um comportamento de alto tráfego e atualizaremos o aplicativo usando uma atualização contínua para uma versão mais recente.

Então, vamos começar a fazer coisas divertidas!

Criação de uma implementação simples de aplicativo da Web

A primeira etapa é criar uma implantação para o nosso servidor Web que cria um contêiner usando a imagem do Nginx.

Copie o código abaixo e salve-o em um arquivo chamado nginx-deployment.yaml.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest
        ports:
        - containerPort: 80

Em seguida, aplique esse Deployment ao cluster usando o seguinte comando:

kubectl apply -f nginx-deployment.yaml

Em seguida, você pode verificar se o pod está em execução: 

kubectl get pods

Expondo o aplicativo com um serviço

Precisamos expor o servidor da Web nginx ao mundo externo por meio de um serviço. Para isso, estamos criando um serviço do tipo NodePort, pois queremos acessar o servidor web nginx de nossa máquina local fora do cluster do Kubernetes.

Portanto, crie um arquivo chamado nginx-service.yaml e adicione o seguinte conteúdo:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

Em seguida, você pode aplicar o serviço com o comando abaixo:

kubectl apply -f nginx-service.yaml

Por último, mas não menos importante, você pode usar o minikube para obter o URL do seu servidor da Web nginx:

minikube service nginx-service --url

Abra esse URL no navegador e você verá a página de boas-vindas do servidor da Web nginx.

Captura de tela de uma página de boas-vindas do servidor da Web nginx em um navegador local.

Dimensionamento do aplicativo

Portanto, temos um pod em funcionamento. Mas pode haver um grande número de usuários visitando nossa página da Web. É por isso que, no Kubernetes, você pode dimensionar rapidamente seu aplicativo para ter mais Pods em funcionamento. 

O serviço detectará automaticamente todos os pods pertencentes a essa implantação e, em seguida, fará o balanceamento de carga das solicitações de entrada para todos os pods que executam o servidor da Web nginx. Isso ajuda a melhorar o desempenho geral da nossa página da Web, caso haja muito tráfego.

Então, vamos dimensionar nosso aplicativo para 3 réplicas usando o comando abaixo:

kubectl scale deployment nginx-deployment --replicas=3

Agora você pode obter todos os pods em execução novamente, que devem ser três:

kubectl get pods

Você também pode usar o comando abaixo para obter todos os pontos de extremidade aos quais o nosso nginx-service está conectado. Isso deve retornar três endpoints, sendo que cada endpoint é seu próprio endereço IP interno do cluster:

kubectl get endpoints nginx-service

Atualizações contínuas

Agora, temos outro benefício significativo do uso do Kubernetes: Atualizações contínuas.

Uma atualização contínua visa a evitar qualquer tempo de inatividade do seu aplicativo da Web. Imagine o prejuízo financeiro para empresas como a Amazon se a página da Web ficasse fora do ar sempre que a Amazon lançasse uma nova versão.

Usando uma atualização contínua, o Kubernetes aumenta a escala de um novo pod, verifica se ele está saudável e, em seguida, diminui a escala do antigo. 

Por padrão, o Kubernetes garante que pelo menos 75% do número desejado de pods estejam em funcionamento, com 25% como o número máximo indisponível. Isso significa que, no nosso caso, em que temos três réplicas em funcionamento, o Kubernetes só adicionará um novo pod por vez, verificará se ele está íntegro e reduzirá a escala de outro pod, se estiver. Ele repetirá esse processo até que todos os pods sejam atualizados para a nova versão.

Então, vamos fazer isso alterando a versão da nossa imagem nginx de latest para 1.23:

kubectl set image deployment/nginx-deployment nginx=nginx:1.23

Você pode então monitorar o status da implementação usando: 

kubectl rollout status deployment/nginx-deployment

O resultado deve ser semelhante a: 

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

E enquanto a implementação estiver em andamento, sua página da Web estará acessível o tempo todo, sem nenhum tempo de inatividade!

Você não acha isso ótimo?

Gerenciando recursos do Kubernetes

O Kubernetes oferece ferramentas avançadas para inspecionar, modificar e excluir recursos de todos os tipos. Entender como gerenciar recursos de forma eficaz garante uma melhor solução de problemas, alocação de recursos e manutenção geral do cluster. 

Nesta seção, vamos nos aprofundar em outros comandos essenciais que ajudam você a gerenciar seus recursos com eficiência e a solucionar problemas em caso de problemas.

Visualização dos recursos do cluster

Antes de alterar qualquer recurso, é essencial visualizar e inspecionar os recursos em execução no momento em seu cluster.

Você pode, por exemplo, listar todos os Pods, Serviços e Implantações em execução para ver o que está acontecendo em seu cluster: 

# list running Pods
kubectl get pods

# list running Services 
kubectl get services

# list running Deployments
kubectl get deployments

Se quiser se aprofundar em um recurso específico, você pode usar ocomando describe :

kubectl describe deployment nginx-deployment

Isso mostrará mais informações, incluindo atualizações contínuas, dimensionamento ou eventos de extração de imagens. Esse é o primeiro ponto para o qual você pode se dirigir se algo der errado.

Você também pode verificar os logs de um pod em execução para ver o que está acontecendo dentro desse pod usando o comando abaixo:

kubectl logs <pod-name>

Exclusão de recursos

Também é essencial limpar os recursos, caso eles não sejam mais usados, para liberar os recursos do cluster para novos aplicativos. 

Você pode excluir um pod usando:

kubectl delete pod <pod-name>

Podemos fazer isso para um de nossos pods nginx. No entanto, um novo pod deve ser ampliado instantaneamente, pois eles são gerenciados por meio de uma implantação, que sempre tenta ter três réplicas em funcionamento. 

Portanto, aqui, precisaríamos excluir o endereço nginx-deployment: 

kubectl delete deployment nginx-deployment

Depois de executar esse comando, todos os pods nginx em execução devem ser excluídos. 

Também podemos excluir todos os recursos em um Namespace. O comando a seguir excluiria todos os nossos recursos, que foram criados no default Namespace, por padrão:

kubectl delete all --all

Conclusão

Parabéns! Você chegou ao fim e deu seus primeiros passos no Kubernetes com sucesso. 

Ao seguir este tutorial, você aprendeu a:

• Configure um cluster local do Kubernetes usando o minikube.
• Trabalhe com pods, implantações, serviços e namespaces (os blocos de construção essenciais do Kubernetes).
• Implante e gerencie um aplicativo da Web simples no Kubernetes.
• Dimensione aplicativos dinamicamente e realize atualizações contínuas sem tempo de inatividade.
• Gerencie os recursos do Kubernetes listando, descrevendo e excluindo-os.

No início, o Kubernetes pode parecer complexo (pelo menos para mim). Mas, ao dividi-lo em conceitos fundamentais, você o torna mais acessível. 

Continue experimentando e implemente mais aplicativos. 

A melhor maneira de aprender o Kubernetes é fazendo, portanto, comece a criar!

Para aprimorar ainda mais suas habilidades com o Kubernetes, considere explorar:

• Trabalhando com ConfigMaps e Secrets: Armazene e gerencie as definições de configuração com segurança.
• Volumes persistentes: Saiba como armazenar dados que sobrevivem às reinicializações do Pod usando volumes persistentes.
• Rede e controladores de entrada: Configure o roteamento baseado em domínio e gerencie o tráfego externo.
• Leme: Use os gráficos do Helm para empacotar e implementar aplicativos complexos com eficiência.
• Kubernetes na nuvem: Faça experiências com serviços gerenciados do Kubernetes, como o AWS EKS, o Azure AKS ou o Google GKE.

Por fim, a trilha Containerization and Virtualization with Docker and Kubernetes no DataCamp é um excelente recurso para você praticar com o Docker e o Kubernetes.