Pular para o conteúdo principal

Lab 8.2 - Roteamento baseado em caminho

Objetivos do Lab​

Ao final deste lab, você será capaz de:

  • Configurar o roteamento baseado em caminhos (path-based).
  • Rotejar o tráfego para diferentes aplicações de acordo com o caminho.
  • Compreender os diferentes pathTypes.
  • Testar o roteamento com múltiplos caminhos.

Duração Estimada​

45-60 minutos

Pré-requisitos​

  • kubectl instalado e configurado.
  • Cluster Kubernetes local funcional com Ingress Controller.
  • Conhecimentos sobre Ingress (Lab 8.1).

Parte 1: Deploy de Múltiplas Aplicações​

Vamos fazer o deploy de duas aplicações diferentes para testar o roteamento baseado em caminhos.

Etapa 1.1: Fazer o Deploy da Aplicação Frontend​

Crie frontend-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: nginx
        image: nginx:1.20
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: frontend-service
spec:
  selector:
    app: frontend
  ports:
  - port: 80
    targetPort: 80

Etapa 1.2: Fazer o Deploy da Aplicação Backend​

Crie backend-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
spec:
  replicas: 2
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - name: httpd
        image: httpd:2.4
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: backend-service
spec:
  selector:
    app: backend
  ports:
  - port: 80
    targetPort: 80

Aplique os deployments:

kubectl apply -f frontend-deployment.yaml
kubectl apply -f backend-deployment.yaml

Parte 2: Configuração do Ingress com Roteamento baseado em caminho​

Etapa 2.1: Criar o Ingress com Múltiplos Caminhos​

Crie ingress-path-based.yaml:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: path-based-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: app.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: frontend-service
            port:
              number: 80
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: backend-service
            port:
              number: 80
      - path: /backend
        pathType: Prefix
        backend:
          service:
            name: backend-service
            port:
              number: 80

Explicação:

  • /: Roteia para o frontend (página inicial).
  • /api: Roteia para o backend.
  • /backend: Rota alternativa para o backend.

Aplique o Ingress:

kubectl apply -f ingress-path-based.yaml

Parte 3: Personalização das Aplicações para Teste​

Para visualizar melhor o roteamento, vamos personalizar as respostas das aplicações.

Etapa 3.1: Personalizar o Frontend​

Crie um ConfigMap para o frontend:

apiVersion: v1
kind: ConfigMap
metadata:
  name: frontend-config
data:
  index.html: |
    <!DOCTYPE html>
    <html>
    <head><title>Frontend Application</title></head>
    <body>
      <h1>Frontend Application</h1>
      <p>Você está na página inicial (/)</p>
      <p><a href="/api">Acessar a API</a></p>
    </body>
    </html>

Aplique e monte o ConfigMap no frontend (modifique o Deployment se necessário).

Etapa 3.2: Personalizar o Backend​

Crie um ConfigMap para o backend:

apiVersion: v1
kind: ConfigMap
metadata:
  name: backend-config
data:
  index.html: |
    <!DOCTYPE html>
    <html>
    <head><title>Backend API</title></head>
    <body>
      <h1>Backend API</h1>
      <p>Você está na API (/api ou /backend)</p>
      <p>Este é o serviço backend</p>
    </body>
    </html>

Parte 4: Testando o Roteamento​

Etapa 4.1: Configurar o Hostname​

Adicione app.local ao seu arquivo /etc/hosts (ou equivalente no Windows) apontando para o IP do Ingress Controller.

Etapa 4.2: Testar os Diferentes Caminhos​

Teste o roteamento:

# Página inicial (deve ir para o frontend)
curl http://app.local/

# API (deve ir para o backend)
curl http://app.local/api

# Backend alternativo (deve ir para o backend)
curl http://app.local/backend

Você deverá ver respostas diferentes de acordo com o caminho.

Parte 5: Compreendendo os pathTypes​

Os pathType determinam como os caminhos são comparados:

  • Exact: Correspondência exata do caminho.
  • Prefix: Correspondência por prefixo (mais comum).
  • ImplementationSpecific: Depende da implementação do Ingress Controller.

Exemplo com Exact​

- path: /api/v1
  pathType: Exact
  backend:
    service:
      name: api-v1-service
      port:
        number: 80

Parte 6: Limpeza​

Remova os recursos:

kubectl delete ingress path-based-ingress
kubectl delete -f frontend-deployment.yaml
kubectl delete -f backend-deployment.yaml
kubectl delete configmap frontend-config backend-config

Resumo do Lab​

Neste lab, você configurou o roteamento baseado em caminhos com Ingress. Você aprendeu a rotear o tráfego para diferentes aplicações de acordo com o caminho da URL, a usar diferentes pathTypes e a testar o roteamento.

Próximos Passos​

O próximo lab mostrará como configurar TLS/SSL com cert-manager para proteger as comunicações HTTPS.

Lab 8.3: TLS/SSL com Cert-Manager

Lab criado em: Dezembro 2024