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:
- Minikube está executando com sucesso
- Um cluster Kubernetes local foi criado
- O cluster está pronto para uso
- 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 Kuberneteskind: Define o tipo de recurso (Deployment)metadata: Fornece nome e rótulos (labels) para a implantaçãospec.replicas: Define o número de réplicas de podselector: Ajuda a implantação a gerenciar os pods corretostemplate: Define a especificação do podcontainers: 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:
- Recurso Ingress (Ingress Resource): Um objeto API Kubernetes que define as regras de roteamento
- 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.
