Comando Kubernetes Expose: Tutorial e Exemplos

Introdução

O comando expose no Kubernetes é uma ferramenta simples, mas poderosa, para tornar um pod ou deployment acessível através de um serviço de rede. Este laboratório irá guiá-lo através do processo de iniciar um cluster Kubernetes, criar um deployment, expô-lo como um serviço e acessar o serviço para verificar a funcionalidade. Ao final deste laboratório, você terá uma compreensão clara de como expor deployments e trabalhar com serviços no Kubernetes.

Iniciar o Minikube

Para executar o Kubernetes localmente, usamos o Minikube, que configura um cluster Kubernetes de nó único. Antes de prosseguir com qualquer operação Kubernetes, certifique-se de que o Minikube está em execução.

Abra um terminal e inicie o Minikube com o seguinte comando:
```
minikube start
```
Isso inicializa o cluster. Se necessário, você pode especificar limites de recursos usando flags como --cpus e --memory para garantir recursos adequados para o cluster.
Verifique se o Minikube está em execução:
```
minikube status
```
Você deve ver que o cluster e seus componentes estão sendo executados com sucesso.

Iniciar o Minikube garante que o Kubernetes esteja pronto para gerenciar deployments e serviços nos passos subsequentes.

Criar um Deployment

No Kubernetes, um deployment é um objeto de recurso que garante que sua aplicação tenha o número desejado de réplicas em execução o tempo todo. Deployments gerenciam pods e ajudam a manter seu estado no cluster. Nesta etapa, você criará um deployment executando o servidor web Nginx.

Use o seguinte comando para criar um deployment chamado hello-world usando a imagem nginx:
```
kubectl create deployment hello-world --image=nginx
```
Este comando cria um deployment com um único pod executando o servidor web Nginx. A flag --image especifica a imagem do container a ser usada. Como as réplicas não são definidas explicitamente, o Kubernetes criará um pod por padrão.
Verifique se o deployment foi criado com sucesso executando:
```
kubectl get deployments
```
Este comando lista todos os deployments no namespace atual, mostrando seus nomes, réplicas desejadas e status.

Ao criar este deployment, você garante que o Kubernetes lida automaticamente com a criação e reinicialização de pods para manter o estado desejado da aplicação.

Explorar o Comando kubectl expose

O comando kubectl expose é usado para criar um novo serviço Kubernetes para expor um recurso existente, como um pod, deployment ou replication controller. Ele simplifica as configurações de rede, criando automaticamente serviços com base no recurso fornecido.

Execute o seguinte comando para visualizar as opções disponíveis para kubectl expose:

kubectl expose -h

Você verá a seguinte saída:

Expose a resource as a new Kubernetes service.

Looks up a deployment, service, replica set, replication controller or pod by name and uses the selector for that
resource as the selector for a new service on the specified port. A deployment or replica set will be exposed as a
service only if its selector is convertible to a selector that service supports, i.e. when the selector contains only
the matchLabels component. Note that if no port is specified via --port and the exposed resource has multiple ports, all
will be re-used by the new service. Also if no labels are specified, the new service will re-use the labels from the
resource it exposes.

Possible resources include (case insensitive):
  pod (po), service (svc), replicationcontroller (rc), deployment (deploy), replicaset (rs)

Examples:
  ## Create a service for a replicated nginx, which serves on port 80 and connects to the containers on port 8000
  kubectl expose rc nginx --port=80 --target-port=8000

  ## Create a service for a replication controller identified by type and name specified in "nginx-controller.yaml",
  which serves on port 80 and connects to the containers on port 8000
  kubectl expose -f nginx-controller.yaml --port=80 --target-port=8000

  ## Create a service for a pod valid-pod, which serves on port 444 with the name "frontend"
  kubectl expose pod valid-pod --port=444 --name=frontend

  ## Create a second service based on the above service, exposing the container port 8443 as port 443 with the name
  "nginx-https"
  kubectl expose service nginx --port=443 --target-port=8443 --name=nginx-https

  ## Create a service for a replicated streaming application on port 4100 balancing UDP traffic and named 'video-stream'.
  kubectl expose rc streamer --port=4100 --protocol=UDP --name=video-stream

  ## Create a service for a replicated nginx using replica set, which serves on port 80 and connects to the containers on
  port 8000
  kubectl expose rs nginx --port=80 --target-port=8000

  ## Create a service for an nginx deployment, which serves on port 80 and connects to the containers on port 8000
  kubectl expose deployment nginx --port=80 --target-port=8000

Expor o Deployment

Para tornar o deployment acessível de fora do cluster Kubernetes, você precisa expô-lo como um serviço. Um serviço no Kubernetes atua como um endpoint de rede estável, mesmo que os pods subjacentes mudem.

Execute o seguinte comando para criar um serviço NodePort chamado hello-service:
```
kubectl expose deployment hello-world --name=hello-service --port=80 --target-port=80 --type=NodePort
```
- A flag --port especifica a porta que o serviço irá expor para clientes externos.
- A flag --target-port define a porta no container para onde o serviço irá rotear o tráfego.
- A flag --type=NodePort torna o serviço acessível em uma porta específica em cada nó do cluster.
Verifique se o serviço foi criado com sucesso:
```
kubectl get services hello-service
```
Este comando exibe detalhes do serviço, incluindo seu tipo e o NodePort atribuído.

Serviços como NodePort permitem que clientes externos interajam com pods no cluster Kubernetes, encaminhando as requisições para as portas corretas do container.

Recuperar Detalhes do Service

Para acessar o serviço exposto, você precisa do NodePort atribuído ao serviço e do endereço IP interno de um nó no cluster. Esses detalhes permitem que clientes externos se conectem à sua aplicação.

Recupere o NodePort atribuído ao hello-service executando:
```
kubectl get service hello-service -o jsonpath='{.spec.ports[0].nodePort}'
```
Este comando extrai o valor do NodePort da definição do serviço.
Obtenha o endereço IP interno de qualquer nó no cluster usando o seguinte comando:
```
kubectl get nodes -o wide
```
Observe o campo INTERNAL-IP na saída. Este endereço IP representa o endereço de rede privado do nó.

Com o NodePort e o InternalIP, você agora tem os detalhes necessários para acessar o serviço externamente.

Acessar o Service

Com o NodePort e o endereço IP do nó, você pode testar o serviço usando uma ferramenta como curl ou um navegador web.

Substitua <NODE_IP> e <NODE_PORT> pelos valores recuperados no passo anterior e, em seguida, execute:
```
curl <NODE_IP>:<NODE_PORT>
```
Se tudo estiver configurado corretamente, você deverá ver a página de boas-vindas padrão do Nginx no terminal. Esta saída confirma que o serviço está em execução e acessível externamente.

<!doctype html>
<html>
  <head>
    <title>Welcome to nginx!</title>
    <style>
      html {
        color-scheme: light dark;
      }
      body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
      }
    </style>
  </head>
  <body>
    <h1>Welcome to nginx!</h1>
    <p>
      If you see this page, the nginx web server is successfully installed and
      working. Further configuration is required.
    </p>

    <p>
      For online documentation and support please refer to
      <a href="http://nginx.org/">nginx.org</a>.<br />
      Commercial support is available at
      <a href="http://nginx.com/">nginx.com</a>.
    </p>

    <p><em>Thank you for using nginx.</em></p>
  </body>
</html>

Acessar o serviço demonstra como o Kubernetes lida com o roteamento de tráfego entre clientes e as portas apropriadas do container.

Limpar Recursos

Após concluir o laboratório, é importante limpar os recursos que você criou para evitar o consumo desnecessário de recursos no seu cluster Kubernetes.

Exclua o hello-service executando:
```
kubectl delete service hello-service
```
Remova o deployment hello-world com o seguinte comando:
```
kubectl delete deployment hello-world
```

A limpeza de recursos garante que seu cluster permaneça em um estado limpo, pronto para experimentos futuros.

Resumo

Neste laboratório, você aprendeu como usar o comando expose no Kubernetes para criar um serviço NodePort. Você expôs um deployment Nginx, acessou-o através do NodePort e verificou sua funcionalidade. Este exercício demonstrou os conceitos básicos dos serviços Kubernetes e como eles fornecem acesso à rede para suas cargas de trabalho.