Pular para o conteúdo

Introdução ao Kubernetes: O que é e como funciona?

Nos últimos anos, o Kubernetes se tornou uma das ferramentas mais populares para gerenciar aplicações em contêineres. Com o aumento da adoção do Docker e de outras tecnologias de contêinerização, a necessidade de uma solução robusta para orquestrar esses contêineres cresceu exponencialmente. Neste artigo, vamos explorar o que é o Kubernetes, como ele funciona e como você pode utilizá-lo em suas aplicações, especialmente com NestJS.

O que é Kubernetes?

Kubernetes, frequentemente abreviado como K8s, é uma plataforma de código aberto para automatizar a implantação, o dimensionamento e a gestão de aplicações em contêineres. Criado inicialmente pela Google, Kubernetes é agora mantido pela Cloud Native Computing Foundation (CNCF). Ele permite que os desenvolvedores e operadores de sistemas implementem e gerenciem aplicações em contêineres de forma eficiente e escalável.

Principais conceitos do Kubernetes

Antes de mergulharmos em como o Kubernetes funciona, é importante entender alguns conceitos fundamentais:

  • Contêiner: Uma unidade leve e portátil que empacota uma aplicação e suas dependências, permitindo que ela seja executada em qualquer ambiente.
  • Cluster: Um conjunto de máquinas físicas ou virtuais que executam o Kubernetes. Cada cluster contém um ou mais nós (nodes).
  • Nó: Uma máquina (física ou virtual) que executa aplicações em contêineres gerenciadas pelo Kubernetes.
  • Pod: A menor unidade de execução no Kubernetes que pode conter um ou mais contêineres.
  • Serviço (Service): Uma abstração que define um conjunto lógico de Pods e uma política para acessá-los.
  • Namespace: Um mecanismo para dividir um cluster em múltiplos ambientes virtuais.

Como Funciona o Kubernetes?

Kubernetes opera através de uma série de componentes que trabalham juntos para garantir que suas aplicações em contêineres sejam executadas de forma eficiente. Vamos explorar os principais componentes e como eles se interagem.

1. Control Plane

O Control Plane é responsável por gerenciar o estado do cluster. Ele toma decisões sobre a execução das aplicações, como onde e quando implantar os Pods. Os principais componentes do Control Plane incluem:

  • API Server: O ponto de entrada para todas as chamadas do Kubernetes. Ele expõe a API do Kubernetes e recebe comandos.
  • Scheduler: Um componente que atribui Pods a nós específicos, com base em recursos disponíveis e requisitos de execução.
  • Controller Manager: Um processo que gerencia controladores que regulam o estado do cluster, garantindo que o número desejado de Pods esteja sempre em execução.
  • etcd: Um armazenamento de chave-valor que armazena todas as informações de configuração e estado do cluster.

2. Nós (Nodes)

Os nós são as máquinas que executam os Pods. Cada nó tem os seguintes componentes:

  • Kubelet: Um agente que garante que os contêineres estejam em execução em um Pod.
  • Kube Proxy: Um componente que gerencia a rede e fornece uma interface de rede para os serviços.
  • Container Runtime: O software que executa os contêineres. O Docker é o runtime mais popular, mas outros runtimes como containerd e CRI-O também são suportados.

3. Pods

Os Pods são a menor unidade de execução no Kubernetes. Eles podem conter um ou mais contêineres que compartilham o mesmo IP, armazenamento e configuração de rede. Os Pods são criados e gerenciados pelo Kubernetes para garantir que suas aplicações estejam sempre disponíveis.

Exemplo Prático: Implantando uma Aplicação NestJS no Kubernetes

Vamos ver um exemplo prático de como implantar uma aplicação NestJS no Kubernetes. Neste exemplo, vamos supor que você já tenha uma aplicação NestJS configurada.

1. Configuração do Docker

Primeiro, precisamos criar uma imagem Docker para a nossa aplicação NestJS. Crie um arquivo Dockerfile no diretório raiz da sua aplicação:

# Dockerfile
FROM node:14

# Define o diretório de trabalho
WORKDIR /usr/src/app

# Copia os arquivos de package.json e package-lock.json
COPY package*.json ./

# Instala as dependências
RUN npm install

# Copia o restante da aplicação
COPY . .

# Expondo a porta 3000
EXPOSE 3000

# Comando para iniciar a aplicação
CMD ["npm", "run", "start:prod"]

2. Construindo a Imagem Docker

Para construir a imagem Docker, execute o seguinte comando no terminal:

docker build -t minha-aplicacao-nestjs .

3. Criando um Deployment no Kubernetes

Agora, vamos criar um arquivo de configuração YAML para o Deployment no Kubernetes. Crie um arquivo chamado deployment.yaml:

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: minha-aplicacao-nestjs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: minha-aplicacao-nestjs
  template:
    metadata:
      labels:
        app: minha-aplicacao-nestjs
    spec:
      containers:
      - name: minha-aplicacao-nestjs
        image: minha-aplicacao-nestjs:latest
        ports:
        - containerPort: 3000

4. Criando um Serviço para Expor a Aplicação

Agora, precisamos criar um serviço para expor nossa aplicação. Crie um arquivo chamado service.yaml:

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: minha-aplicacao-nestjs
spec:
  type: LoadBalancer
  ports:
    - port: 80
      targetPort: 3000
  selector:
    app: minha-aplicacao-nestjs

5. Implantando no Kubernetes

Agora que temos nossos arquivos de configuração, vamos implantar nossa aplicação no Kubernetes. Execute os seguintes comandos:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Esses comandos criarão o Deployment e o Serviço no seu cluster Kubernetes.

6. Acessando a Aplicação

Após a implantação, você pode encontrar o endereço IP do serviço com o seguinte comando:

kubectl get services

A aplicação deve estar acessível através do IP listado.

Melhores Práticas para Trabalhar com Kubernetes

Ao trabalhar com Kubernetes, algumas práticas podem ajudar a otimizar sua experiência:

  1. Versionamento de Imagens: Sempre use tags de versão em suas imagens Docker para evitar que o Kubernetes puxe a última versão não testada.
  2. Recursos de Limitação: Defina limites de CPU e memória para seus Pods para evitar que uma aplicação monopolize os recursos do cluster.
  3. Liveness e Readiness Probes: Utilize probes para monitorar a saúde dos seus Pods, garantindo que apenas Pods saudáveis recebam tráfego.
  4. Namespaces: Use namespaces para separar diferentes ambientes (desenvolvimento, teste, produção) dentro de um único cluster.
  5. Monitoramento e Logging: Implemente soluções de monitoramento e logging para ter visibilidade do que está acontecendo no seu cluster.

Conclusão

Kubernetes é uma ferramenta poderosa que pode revolucionar a forma como você implanta e gerencia suas aplicações em contêineres. Com sua capacidade de automatizar tarefas complexas e garantir alta disponibilidade, Kubernetes se tornou uma escolha popular para empresas de todos os tamanhos. Neste artigo, discutimos os conceitos básicos do Kubernetes, como ele funciona e um exemplo prático de como implantar uma aplicação NestJS.

Se você está apenas começando sua jornada com Kubernetes, não se preocupe. A curva de aprendizado pode ser íngreme, mas com prática e paciência, você se tornará um expert em orquestração de contêineres.

Compartilhe sua Opinião!

Gostou do artigo? Tem alguma dúvida ou experiência para compartilhar sobre Kubernetes? Deixe seu comentário abaixo! Sua opinião é importante para nós e pode ajudar outros leitores a aprender mais sobre essa tecnologia incrível.

Marcações: