Expor Aplicações Kubernetes

KubernetesBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como expor aplicações Kubernetes usando diversas técnicas, incluindo a criação de serviços internos e externos, trabalhando com rótulos (labels) e explorando os fundamentos do Ingress. Você começará configurando um cluster Kubernetes local usando Minikube, em seguida, implantará uma aplicação NGINX de exemplo e a exporá tanto internamente quanto externamente. Você também explorará o uso de rótulos para organizar e selecionar recursos e, finalmente, terá uma breve introdução ao Ingress com um exemplo simples. Observe que Ingress é um tópico complexo, e este laboratório fornece apenas uma introdução básica ao conceito.

Iniciar o Cluster Kubernetes

Nesta etapa, você aprenderá como iniciar e verificar um cluster Kubernetes local usando Minikube. Este é um primeiro passo essencial para desenvolver e testar aplicações Kubernetes em sua máquina local.

Primeiro, inicie o cluster Minikube:

minikube start

Exemplo de saída:

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Automatically selected the docker driver
📌  Using Docker driver with root permissions
🔥  Creating kubernetes in kubernetes cluster
🔄  Restarting existing kubernetes cluster
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23 ...
🚀  Launching Kubernetes ...
🌟  Enabling addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace

Verifique o status do cluster usando múltiplos comandos:

minikube status
kubectl get nodes

Exemplo de saída para minikube status:

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

Exemplo de saída para kubectl get nodes:

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   1m    v1.26.1

Esses comandos confirmam que:

  1. Minikube está executando com sucesso
  2. Um cluster Kubernetes local foi criado
  3. O cluster está pronto para uso
  4. Você tem um cluster de nó único com capacidades de plano de controle

Implantar uma Aplicação de Exemplo

Nesta etapa, você aprenderá como criar e implantar uma aplicação Kubernetes usando um manifesto YAML. Criaremos uma implantação simples de um servidor web NGINX para demonstrar o processo de definição e aplicação de recursos Kubernetes.

Primeiro, crie um diretório para seus manifestos Kubernetes:

mkdir -p ~/project/k8s-manifests
cd ~/project/k8s-manifests

Crie um arquivo YAML para uma implantação NGINX:

nano nginx-deployment.yaml

Adicione o seguinte manifesto de implantação:

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

Salve o arquivo (Ctrl+X, depois Y, depois Enter).

Aplique a implantação ao cluster Kubernetes:

kubectl apply -f nginx-deployment.yaml

Exemplo de saída:

deployment.apps/nginx-deployment created

Verifique a implantação e os pods:

kubectl get deployments
kubectl get pods

Exemplo de saída para kubectl get deployments:

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           1m

Exemplo de saída para kubectl get pods:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          1m
nginx-deployment-xxx-zzz            1/1     Running   0          1m
nginx-deployment-xxx-www            1/1     Running   0          1m

Aguarde até que os pods estejam no estado "Running" antes de prosseguir.

Vamos detalhar o manifesto YAML:

  • apiVersion: Especifica a versão da API Kubernetes
  • kind: Define o tipo de recurso (Deployment)
  • metadata: Fornece nome e rótulos (labels) para a implantação
  • spec.replicas: Define o número de réplicas de pod
  • selector: Ajuda a implantação a gerenciar os pods corretos
  • template: Define a especificação do pod
  • containers: Especifica a imagem do container e a porta

Esta implantação cria três pods NGINX idênticos, demonstrando como o Kubernetes gerencia aplicações em containers.

Criar um Serviço via YAML para Expor a Aplicação Interna ou Externamente

Nesta etapa, você aprenderá como criar Serviços Kubernetes para expor sua implantação NGINX interna e externamente. Demonstraremos dois tipos de serviço comuns: ClusterIP e NodePort.

Primeiro, navegue até o diretório do seu projeto:

cd ~/project/k8s-manifests

Crie um arquivo YAML de serviço ClusterIP:

nano nginx-clusterip-service.yaml

Adicione o seguinte manifesto de serviço:

apiVersion: v1
kind: Service
metadata:
  name: nginx-clusterip-service
spec:
  selector:
    app: nginx
  type: ClusterIP
  ports:
    - port: 80
      targetPort: 80

Agora, crie um arquivo YAML de serviço NodePort:

nano nginx-nodeport-service.yaml

Adicione o seguinte manifesto de serviço:

apiVersion: v1
kind: Service
metadata:
  name: nginx-nodeport-service
spec:
  selector:
    app: nginx
  type: NodePort
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30080

Aplique ambas as configurações de serviço:

kubectl apply -f nginx-clusterip-service.yaml
kubectl apply -f nginx-nodeport-service.yaml

Exemplo de saída:

service/nginx-clusterip-service created
service/nginx-nodeport-service created

Verifique os serviços:

kubectl get services

Exemplo de saída:

NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes                  ClusterIP   10.96.0.1        <none>        443/TCP        30m
nginx-clusterip-service     ClusterIP   10.104.xxx.xxx   <none>        80/TCP         1m
nginx-nodeport-service      NodePort    10.108.yyy.yyy   <none>        80:30080/TCP   1m

Para acessar o serviço NodePort, obtenha o IP do Minikube:

minikube ip

Exemplo de saída:

192.168.49.2

Principais diferenças entre os tipos de serviço:

  • ClusterIP: Acesso interno ao cluster apenas
  • NodePort: Expõe o serviço em uma porta estática no IP de cada nó
  • Intervalo NodePort: 30000-32767

Verificar a Configuração do Serviço

Nesta etapa, você aprenderá como usar kubectl describe service para inspecionar a configuração detalhada dos serviços Kubernetes e entender suas propriedades de rede.

Primeiro, certifique-se de estar no diretório do projeto:

cd ~/project/k8s-manifests

Descreva o serviço ClusterIP em detalhes:

kubectl describe service nginx-clusterip-service

Exemplo de saída:

Name:              nginx-clusterip-service
Namespace:         default
Labels:            <none>
Annotations:       <none>
Selector:          app=nginx
Type:              ClusterIP
IP Family Policy:  SingleStack
IP Families:       IPv4
IP:                10.104.xxx.xxx
IPs:               10.104.xxx.xxx
Port:              <unset>  80/TCP
TargetPort:        80/TCP
Endpoints:         10.244.0.7:80,10.244.0.8:80,10.244.0.9:80
Session Affinity:  None
Events:            <none>

Agora, descreva o serviço NodePort:

kubectl describe service nginx-nodeport-service

Exemplo de saída:

Name:                     nginx-nodeport-service
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=nginx
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.108.yyy.yyy
IPs:                      10.108.yyy.yyy
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  30080/TCP
Endpoints:                10.244.0.7:80,10.244.0.8:80,10.244.0.9:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

Inspecione os endpoints do serviço para verificar a conectividade de rede:

kubectl get endpoints

Exemplo de saída:

NAME                        ENDPOINTS                               AGE
kubernetes                  192.168.49.2:8443                       45m
nginx-clusterip-service     10.244.0.7:80,10.244.0.8:80,10.244.0.9:80   15m
nginx-nodeport-service      10.244.0.7:80,10.244.0.8:80,10.244.0.9:80   15m

Informações chave para entender a partir da descrição do serviço:

  • Selector: Mostra quais pods fazem parte do serviço
  • IP: Endereço IP interno do cluster do serviço
  • Endpoints: Lista de endereços IP e portas dos pods que servem o serviço
  • Port e TargetPort: Definem como o tráfego é roteado
  • NodePort: Porta externa para o tipo de serviço NodePort

Usar Labels para Organizar e Selecionar Recursos

Nesta etapa, você aprenderá como usar labels no Kubernetes para organizar e selecionar recursos de forma eficiente. Labels são pares chave-valor que ajudam a gerenciar e organizar objetos Kubernetes.

Primeiro, verifique as labels atuais em seus pods:

kubectl get pods --show-labels

Exemplo de saída:

NAME                                READY   STATUS    RESTARTS   AGE   LABELS
nginx-deployment-xxx-yyy            1/1     Running   0          30m   app=nginx,pod-template-hash=xxx
nginx-deployment-xxx-zzz            1/1     Running   0          30m   app=nginx,pod-template-hash=yyy
nginx-deployment-xxx-www            1/1     Running   0          30m   app=nginx,pod-template-hash=zzz

Selecione pods usando labels específicas:

kubectl get pods -l app=nginx

Exemplo de saída:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          30m
nginx-deployment-xxx-zzz            1/1     Running   0          30m
nginx-deployment-xxx-www            1/1     Running   0          30m

Vamos adicionar uma label personalizada a um dos pods:

kubectl label pods nginx-deployment-xxx-yyy environment=development

Substitua nginx-deployment-xxx-yyy pelo nome de um dos seus pods.

Exemplo de saída:

pod/nginx-deployment-xxx-yyy labeled

Agora, selecione pods com múltiplos seletores de label:

kubectl get pods -l app=nginx,environment=development

Exemplo de saída:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          30m

Remova uma label de um pod:

kubectl label pods nginx-deployment-xxx-yyy environment-

Exemplo de saída:

pod/nginx-deployment-xxx-yyy unlabeled

Demonstre a seleção de label em serviços:

kubectl describe service nginx-clusterip-service

Procure a seção "Selector", que mostra como os serviços usam labels para identificar pods.

Pontos-chave sobre labels:

  • Labels são pares chave-valor anexados a objetos Kubernetes
  • Usados para organizar, selecionar e filtrar recursos
  • Podem ser adicionados, modificados ou removidos dinamicamente
  • Serviços e implantações usam labels para gerenciar pods relacionados

Excluir e Gerenciar Serviços

Nesta etapa, você aprenderá como excluir e gerenciar serviços Kubernetes usando comandos kubectl. Compreender o gerenciamento de serviços é crucial para manter e limpar seus recursos Kubernetes.

Primeiro, liste os serviços atuais:

kubectl get services

Exemplo de saída:

NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes                  ClusterIP   10.96.0.1        <none>        443/TCP        1h
nginx-clusterip-service     ClusterIP   10.104.xxx.xxx   <none>        80/TCP         45m
nginx-nodeport-service      NodePort    10.108.yyy.yyy   <none>        80:30080/TCP   45m

Exclua um serviço específico usando kubectl delete:

kubectl delete service nginx-clusterip-service

Exemplo de saída:

service "nginx-clusterip-service" deleted

Verifique a exclusão do serviço:

kubectl get services

Exemplo de saída:

NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes                  ClusterIP   10.96.0.1        <none>        443/TCP        1h
nginx-nodeport-service      NodePort    10.108.yyy.yyy   <none>        80:30080/TCP   45m

Para demonstrar a exclusão de múltiplos serviços de forma mais clara, vamos recriar nossos serviços e, em seguida, excluí-los juntos:

## Recreate services
kubectl apply -f nginx-clusterip-service.yaml
kubectl apply -f nginx-nodeport-service.yaml
## Delete multiple services at once
kubectl delete service nginx-clusterip-service nginx-nodeport-service

Exemplo de saída:

service "nginx-clusterip-service" deleted
service "nginx-nodeport-service" deleted

Verifique se todos os serviços foram removidos (exceto o serviço kubernetes padrão):

kubectl get services

Exemplo de saída:

NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   1h

Pontos-chave sobre a exclusão de serviços:

  • Excluir um serviço remove o endpoint de rede
  • Os pods não são excluídos quando um serviço é removido
  • O serviço kubernetes padrão não pode ser excluído
  • Você pode excluir serviços usando o nome, arquivo YAML ou labels
  • Múltiplos serviços podem ser excluídos simultaneamente, listando-os ou usando seletores de label

Introdução aos Conceitos Básicos de Ingress e Exemplo Simples em YAML

Nesta etapa, você aprenderá sobre Kubernetes Ingress, uma forma poderosa de gerenciar o acesso externo a serviços em um cluster Kubernetes.

O que é Ingress?

Ingress é um objeto API que gerencia o acesso externo a serviços em um cluster Kubernetes, tipicamente HTTP. Ingress fornece:

  • Balanceamento de carga (Load balancing): Distribui o tráfego para múltiplos serviços de backend
  • Terminação SSL/TLS: Lida com conexões seguras
  • Hospedagem virtual baseada em nome (Name-based virtual hosting): Roteia as requisições para diferentes serviços com base no nome do host
  • Roteamento baseado em caminho (Path-based routing): Roteia as requisições para diferentes serviços com base no caminho da URL

Ingress consiste em dois componentes:

  1. Recurso Ingress (Ingress Resource): Um objeto API Kubernetes que define as regras de roteamento
  2. Controlador Ingress (Ingress Controller): A implementação que aplica as regras definidas no Recurso Ingress

Nota: Este laboratório fornece apenas uma introdução básica ao Ingress. Em ambientes de produção, as configurações de Ingress podem ser muito mais complexas, incluindo roteamento avançado, autenticação, limitação de taxa e muito mais.

Vamos habilitar o addon Ingress no Minikube:

minikube addons enable ingress

Exemplo de saída:

💡  ingress is an addon maintained by Kubernetes. For any concerns contact minikube on GitHub.
🔉  ingress was successfully enabled

Crie uma implantação para duas aplicações de exemplo:

kubectl create deployment web1 --image=nginx:alpine
kubectl create deployment web2 --image=httpd:alpine

Exponha essas implantações como serviços:

kubectl expose deployment web1 --port=80 --type=ClusterIP --name=web1-service
kubectl expose deployment web2 --port=80 --type=ClusterIP --name=web2-service

Crie um arquivo YAML Ingress:

nano ingress-example.yaml

Adicione a seguinte configuração Ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
    - http:
        paths:
          - path: /web1
            pathType: Prefix
            backend:
              service:
                name: web1-service
                port:
                  number: 80
          - path: /web2
            pathType: Prefix
            backend:
              service:
                name: web2-service
                port:
                  number: 80

Componentes-chave desta configuração Ingress:

  • metadata.annotations: Configurações específicas para o controlador Ingress
  • spec.rules: Define como o tráfego é roteado para os serviços
  • path: Caminho da URL que será correspondido
  • pathType: Como o caminho deve ser correspondido (Prefix, Exact, ou ImplementationSpecific)
  • backend.service: O serviço e a porta para rotear o tráfego

Aplique a configuração Ingress:

kubectl apply -f ingress-example.yaml

Verifique o recurso Ingress:

kubectl get ingress

Exemplo de saída:

NAME              CLASS   HOSTS   ADDRESS        PORTS   AGE
example-ingress   nginx   *       192.168.49.2   80      1m

Verifique os detalhes do Ingress:

kubectl describe ingress example-ingress

O exemplo de saída mostrará as regras de roteamento e os serviços de backend.

Testando o Ingress:

## Get the Minikube IP
minikube ip

## Test access to the services through Ingress
curl $(minikube ip)/web1
curl $(minikube ip)/web2

Cada comando deve retornar a página padrão do respectivo servidor web.

Em ambientes de produção, o Ingress pode ser configurado com:

  • Múltiplas regras baseadas em nome de host
  • Certificados TLS para HTTPS
  • Mecanismos de autenticação
  • Limitação de taxa
  • Configurações de tempo limite personalizadas
  • Afinidade de sessão
  • E muitos mais recursos avançados

Para uma cobertura mais abrangente do Ingress, consulte a documentação do Kubernetes e considere explorar a documentação dedicada do controlador Ingress, como NGINX Ingress ou Traefik.

Resumo

Neste laboratório, você aprendeu como iniciar e verificar um cluster Kubernetes local usando o Minikube, o que é essencial para desenvolver e testar aplicações Kubernetes em sua máquina local. Em seguida, você criou e implantou uma implantação simples de um servidor web NGINX usando um manifesto YAML, demonstrando o processo de definição e aplicação de recursos Kubernetes.

Você aprendeu como criar serviços Kubernetes para expor sua aplicação tanto internamente (usando ClusterIP) quanto externamente (usando NodePort), e como usar rótulos (labels) para organizar e selecionar recursos de forma eficaz. Você também praticou o gerenciamento de serviços, incluindo a exclusão de serviços individuais e múltiplos.

Finalmente, você foi introduzido aos conceitos básicos de Kubernetes Ingress e viu um exemplo simples de roteamento baseado em caminho. Embora este laboratório tenha fornecido apenas uma breve introdução ao Ingress, ele demonstrou os conceitos fundamentais de roteamento de tráfego externo para diferentes serviços com base nos caminhos da URL.

Para uma compreensão mais profunda do Ingress e suas capacidades, você pode querer explorar recursos dedicados ou laboratórios focados especificamente em controladores e configurações Kubernetes Ingress.