Ingress para acesso externo
Configure o Ingress para gerenciar o acesso externo aos serviços, oferecendo roteamento HTTP/S e balanceamento de carga.
Ingress para acesso externo é uma aula grátis de DevOps Bootcamp no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de DevOps Bootcamp, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de DevOps Bootcamp inclui 4 aulas no total.
Além de NodePort e LoadBalancer
Exploramos diferentes tipos de serviço do Kubernetes, como NodePort e LoadBalancer, para expor aplicações externamente.
Embora sejam úteis, eles podem se tornar difíceis de gerenciar quando os requisitos de acesso externo são complexos, especialmente quando você precisa hospedar muitas aplicações ou APIs em um único endereço IP com regras de roteamento específicas.
É nesse contexto que a Entrada entra em cena, oferecendo uma solução mais avançada e flexível.
Conhecendo a Entrada do Kubernetes
A Entrada é um objeto de API do Kubernetes que gerencia o acesso externo aos serviços de um cluster, principalmente para tráfego HTTP e HTTPS.
- Ela funciona como um único ponto de entrada para solicitações externas.
- Permite o roteamento HTTP/S com base em nomes de host ou caminhos de URL.
- Também pode oferecer recursos como encerramento de SSL/TLS e balanceamento de carga.
Pense na Entrada como um controlador inteligente de tráfego que direciona o tráfego da web para os serviços internos corretos.
O Controlador de Entrada
O próprio recurso de Entrada é apenas um conjunto de regras; ele não lida diretamente com o tráfego. Para tornar a Entrada funcional, você precisa ter um Controlador de Entrada em execução no cluster.
O Controlador de Entrada observa os recursos de Entrada e configura um balanceador de carga externo (ou proxy reverso) de acordo com as regras definidas.
Entre os controladores de Entrada populares estão Nginx, Traefik e controladores específicos de provedores de nuvem, como o GCE Ingress para o Google Cloud ou o AWS Load Balancer Controller.
Como Funcionam as Regras de Entrada
A Entrada define regras que mapeiam solicitações externas recebidas para serviços de backend específicos dentro do cluster. Normalmente, essas regras especificam:
- Host: O nome de domínio (por exemplo,
www.my-app.com). - Caminho: O caminho da URL (por exemplo,
/api,/blog). - Serviço de Backend: O serviço Kubernetes e a porta para os quais o tráfego deve ser encaminhado.
O Controlador de Entrada avalia essas regras para cada solicitação recebida, a fim de determinar o destino correto.
Criando um YAML de Entrada
Assim como outros recursos do Kubernetes, a Entrada é definida usando um manifesto YAML. Veja uma estrutura básica que ilustra os campos principais:
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: my-app-ingress
spec:
rules:
- host: myapp.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: my-web-service
port:
number: 80Entrada Simples Baseada em Caminho
Vamos criar um recurso de Entrada que encaminhe todo o tráfego do caminho raiz (/) de myapp.example.com para um serviço chamado my-web-service na porta 80.
Certifique-se de que haja uma Implantação e um Serviço chamados my-web-service em execução no cluster antes de aplicar esta Entrada.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: basic-app-ingress
annotations:
nginx.ingress.kubernetes.io/rewrite-target: /
spec:
rules:
- host: myapp.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: my-web-service
port:
number: 80Implantando a Sua Entrada
Para implantar o recurso de Entrada, salve o YAML em um arquivo (por exemplo, basic-ingress.yaml) e use kubectl apply:
kubectl apply -f basic-ingress.yaml
Você pode verificar o status da sua Entrada com kubectl get ingress. Em seguida, o Controlador de Entrada configurará o balanceador de carga externo com base nessas regras.
Para testar, normalmente será necessário atualizar o arquivo local /etc/hosts (ou o DNS) para apontar myapp.example.com para o endereço IP externo do Controlador de Entrada.
Exemplo de Roteamento Baseado em Host
A Entrada é perfeita para hospedar várias aplicações em um único endereço IP externo usando nomes de host diferentes. Neste exemplo, app1.example.com é encaminhado para service-app1, e app2.example.com é encaminhado para service-app2.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: host-routing-ingress
spec:
rules:
- host: app1.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: service-app1
port:
number: 80
- host: app2.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: service-app2
port:
number: 80Vários Caminhos, Um Host
Você também pode encaminhar diferentes caminhos de URL no mesmo nome de host para diferentes serviços de backend. Isso é ideal para arquiteturas de microsserviços ou para diferentes seções de uma única aplicação.
Por exemplo, as solicitações para api.example.com/users vão para users-service, enquanto as solicitações para api.example.com/products vão para products-service.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: path-routing-ingress
spec:
rules:
- host: api.example.com
http:
paths:
- path: /users
pathType: Prefix
backend:
service:
name: users-service
port:
number: 80
- path: /products
pathType: Prefix
backend:
service:
name: products-service
port:
number: 80Verificação da Finalidade da Entrada
Quais das opções a seguir são os principais benefícios do uso da Entrada do Kubernetes?
Recapitulação: Entrada para Roteamento Inteligente
Excelente trabalho! Você aprendeu sobre a Entrada do Kubernetes, um componente essencial para gerenciar como usuários externos interagem com as suas aplicações.
- A Entrada oferece roteamento HTTP/S flexível com base em nomes de host e caminhos de URL.
- Ela requer um Controlador de Entrada (como o Nginx) para observar as regras de Entrada e configurar o roteamento.
- Ela simplifica a exposição de vários serviços por meio de um único endereço IP externo, tornando o cluster mais eficiente e fácil de gerenciar.
Dominar a Entrada é essencial para criar aplicações robustas e acessíveis nativas da nuvem!
Perguntas Frequentes
A aula “Ingress para acesso externo” é grátis?
Sim — o texto completo de “Ingress para acesso externo” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de DevOps Bootcamp, atualize para CoddyKit PRO. O curso de DevOps Bootcamp inclui 4 aulas no total.
O que vou aprender em “Ingress para acesso externo”?
Configure o Ingress para gerenciar o acesso externo aos serviços, oferecendo roteamento HTTP/S e balanceamento de carga. Você pratica DevOps Bootcamp com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar DevOps Bootcamp?
Nenhuma experiência prévia é necessária. DevOps Bootcamp no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.
Quanto tempo leva a aula “Ingress para acesso externo”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de DevOps Bootcamp?
Sim. Cada aula de DevOps Bootcamp inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Expondo aplicações com serviços
- Tipos de serviço: ClusterIP, NodePort, LoadBalancer
- Ingress para acesso externo
- DNS e descoberta de serviços