Como exibir aplicativos que usam serviços

Nesta página você aprende a criar os serviços do Kubernetes em um cluster do Google Kubernetes Engine. Para uma explicação e discussão sobre o conceito e os vários tipos de serviços, consulte este artigo.

Introdução

Um serviço agrupa um conjunto de endpoints do pod em um único recurso. É possível configurar várias maneiras de acessar o agrupamento. Por padrão, você recebe um endereço IP de cluster estável que os clientes dentro do cluster podem usar para contatar pods no serviço. Um cliente envia uma solicitação ao endereço IP estável e a solicitação é encaminhada a um dos pods no serviço.

Existem cinco tipos de serviços:

  • ClusterIP (padrão)
  • NodePort
  • LoadBalancer
  • ExternalName
  • Sem comando

Este tópico tem vários exercícios. Em cada um deles, você cria uma implantação e expõe os pods criando um serviço. Em seguida, envia uma solicitação HTTP para ele.

Antes de começar

Prepare-se para a tarefa tomando as seguintes medidas:

  • Verifique se você ativou a API Google Kubernetes Engine.
  • Ativar a API Google Kubernetes Engine
  • Verifique se o SDK do Cloud está instalado.
  • Defina o ID do projeto padrão:
    gcloud config set project [PROJECT_ID]
  • Se você estiver trabalhando com clusters zonais, defina a zona de computação padrão:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Se você estiver trabalhando com clusters regionais, defina a região de computação padrão:
    gcloud config set compute/region [COMPUTE_REGION]
  • Atualize o gcloud para a versão mais recente:
    gcloud components update

Como criar um serviço do tipo ClusterIP

kubectl apply

Veja aqui o manifesto de uma implantação:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  selector:
    matchLabels:
      app: metrics
      department: sales
  replicas: 3
  template:
    metadata:
      labels:
        app: metrics
        department: sales
    spec:
      containers:
      - name: hello
        image: "gcr.io/google-samples/hello-app:2.0"

Copie o manifesto para um arquivo denominado my-deployment.yaml e crie a implantação:

kubectl apply -f my-deployment.yaml

Verifique se três pods estão em execução:

kubectl get pods

A saída mostra três pods em execução:

NAME                              READY     STATUS    RESTARTS   AGE
service-how-to-76699757f9-h4xk4   1/1       Running   0          4s
service-how-to-76699757f9-tjcfq   1/1       Running   0          4s
service-how-to-76699757f9-wt9d8   1/1       Running   0          4s

Veja aqui um manifesto de um serviço do tipo ClusterIP:

apiVersion: v1
kind: Service
metadata:
  name: my-cip-service
spec:
  type: ClusterIP
  selector:
    app: metrics
    department: sales
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

O serviço tem um seletor que especifica dois rótulos:

  • app: metrics
  • department: sales

Cada pod criado na implantação tem esses dois rótulos. Assim, eles se tornarão membros desse serviço.

Copie o manifesto para um arquivo chamado my-cip-service.yaml e crie o serviço:

kubectl apply -f my-cip-service.yaml

Aguarde um momento para que o Kubernetes atribua um endereço interno estável ao serviço e, em seguida, visualize-o.

kubectl get service my-cip-service --output yaml

A saída mostra um valor para o clusterIP.

spec:
  clusterIP: 10.59.241.241

Anote o valor do clusterIP para usar depois.

Console

Criar uma implantação

  1. Visite o menu "Cargas de trabalho" do Google Kubernetes Engine no Console do GCP.

    Acessar o menu "Cargas de trabalho"

  2. Clique em Implantar.

  3. Na caixa Contêiner, em Imagem do contêiner, insira gcr.io/google-samples/hello-app:2.0 e clique em Concluir.

  4. Em Nome do aplicativo, insira my-deployment.

  5. Em Rótulos, crie dois rótulos. Em um, defina a Chave como app e o Valor como metrics. No outro, defina a Chave como department e o Valor como sales.

  6. No menu suspenso Cluster, escolha o cluster que quiser.

  7. Clique em Implantar.

  8. Quando a implantação estiver pronta, a página Detalhes da implantação abrirá e será possível ver que ela conta com um ou mais pods em execução.

Crie um serviço para expor a implantação

  1. Na página Detalhes da implantação, clique em Expor.

  2. Na caixa Novo mapeamento de porta, defina a Porta como 80 e a Porta de destino como 8080. Deixe o Protocolo definido como TCP e clique em Concluir.

  3. No menu suspenso Tipo de serviço, selecione o IP do cluster.

  4. Em Nome do serviço, digite my-cip-service.

  5. Clique em Expor.

  6. Quando o serviço estiver pronto, a página Detalhes do serviço abrirá para que você veja os detalhes. Em especial, o valor do IP do cluster que o Kubernetes atribuiu ao serviço. Esse é o endereço IP que os clientes internos usarão para chamá-lo. Anote o valor do IP do cluster para uso posterior.

Como acessar o serviço

Liste os pods em execução:

kubectl get pods

Na saída, copie o nome de Pod que começa com my-deployment.

NAME                               READY     STATUS    RESTARTS   AGE
my-deployment-6897d9577c-7z4fv     1/1       Running   0          5m

Coloque um shell em um dos seus contêineres em execução:

kubectl exec -it [YOUR_POD_NAME] -- sh

em que [YOUR_POD_NAME] é o nome de um dos pods na my-deployment.

No shell, instale o curl:

apk add --no-cache curl

No contêiner, faça uma solicitação ao serviço usando o endereço IP do cluster e a porta 80. Observe que 80 é o valor do campo port do serviço. Esta é a porta que você usará como cliente.

curl [CLUSTER_IP]:80

em que [CLUSTER_IP] é o valor do clusterIP no serviço.

A solicitação é encaminhada para um dos pods membro na porta TCP 8080, que é o valor do campo targetPort. Observe que cada um dos pods membro do serviço precisa ter um contêiner escutando a porta 8080.

A resposta mostra a saída do hello-app:

Hello, world!
Version: 2.0.0
Hostname: service-how-to-76699757f9-hsb5x

Para sair do shell para o contêiner, insira exit.

Como criar um serviço do tipo NodePort

kubectl apply

Veja aqui o manifesto de uma implantação:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment-50000
spec:
  selector:
    matchLabels:
      app: metrics
      department: engineering
  replicas: 3
  template:
    metadata:
      labels:
        app: metrics
        department: engineering
    spec:
      containers:
      - name: hello
        image: "gcr.io/google-samples/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50000"

Observe o objeto env no manifesto. O objeto env especifica que a variável de ambiente PORT para o contêiner em execução terá um valor de 50000. O aplicativo hello-app escuta a porta especificada pela variável de ambiente PORT. Portanto, neste exercício, você está dizendo ao contêiner para escutar a porta 50000.

Copie o manifesto para um arquivo denominado my-deployment-50000.yaml e crie a implantação:

kubectl apply -f my-deployment-50000.yaml

Verifique se três pods estão em execução:

kubectl get pods

Veja aqui um manifesto de um serviço do tipo NodePort:

apiVersion: v1
kind: Service
metadata:
  name: my-np-service
spec:
  type: NodePort
  selector:
    app: metrics
    department: engineering
  ports:
  - protocol: TCP
    port: 80
    targetPort: 50000

Copie o manifesto para um arquivo chamado my-np-service.yaml e crie o serviço:

kubectl apply -f my-np-service.yaml

Visualize o serviço:

kubectl get service my-np-service --output yaml

A saída mostra um valor nodePort.

...
  spec:
    ...
    ports:
    - nodePort: 30876
      port: 80
      protocol: TCP
      targetPort: 50000
    selector:
      app: metrics
      department: engineering
    sessionAffinity: None
    type: NodePort
...

Se os nós em seu cluster tiverem endereços IP externos, localize um deles:

kubectl get nodes --output wide

A saída mostra os endereços IP externos dos nós:

NAME          STATUS    ROLES     AGE    VERSION        EXTERNAL-IP
gke-svc-...   Ready     none      1h     v1.9.7-gke.6   203.0.113.1

Nem todos os clusters têm endereços IP externos para nós. Por exemplo, os nós em clusters particulares não têm.

Crie uma regra de firewall para permitir o tráfego TCP na porta do nó:

gcloud compute firewall-rules create test-node-port --allow tcp:[NODE_PORT]

em que: [NODE_PORT] é o valor do campo nodePort do seu serviço.

Console

Criar uma implantação

  1. Visite o menu "Cargas de trabalho" do Google Kubernetes Engine no Console do GCP.

    Acessar o menu "Cargas de trabalho"

  2. Clique em Implantar.

  3. Na caixa Contêiner, em Caminho da imagem, digite gcr.io/google-samples/hello-app:2.0. Clique em Adicionar variáveis de ambiente. Em Chave, digite PORT. Em Valor, digite 50000. Clique em Concluído.

  4. Na seção "Configuração", em Nome do aplicativo, digite my-deployment-50000.

  5. Em Rótulos, crie dois rótulos. Em um, defina a Chave como app e o Valor como metrics. No outro, defina a Chave como department e o Valor como engineering.

  6. No menu suspenso Cluster, escolha o cluster que quiser.

  7. Clique em Implantar.

  8. Quando a implantação estiver pronta, a página Detalhes da implantação abrirá e será possível ver que ela conta com um ou mais pods em execução.

Crie um serviço para expor a implantação

  1. Na página Detalhes da implantação, em Serviços, clique em Expor.

  2. Na caixa Novo mapeamento de porta, defina a Porta como 80 e a Porta de destino como 50000. Deixe o Protocolo definido como TCP e clique em Concluir.

  3. No menu suspenso Tipo de serviço, selecione Porta do nó.

  4. Em Nome do serviço, digite my-np-service.

  5. Clique em Expor.

  6. Quando o serviço estiver pronto, a página Detalhes do serviço abrirá para que você veja os detalhes. Em Portas, veja o valor da Porta do nó que o Kubernetes atribuiu ao serviço. Anote-o para uso posterior.

Crie uma regra de firewall para a porta do nó

  1. Acesse o menu Regras de firewall no Console do GCP.

    Acessar o menu "Regras de firewall"

  2. Clique em Criar regra de firewall.

  3. Em Nome, digite test-node-port.

  4. No menu suspenso Destinos, selecione Todas as instâncias na rede.

  5. Em Intervalos de IPs de origem, digite 0.0.0.0/0.

  6. Em Porta e protocolos especificados, selecione tcp e insira o valor da porta do nó.

  7. Clique em Criar.

Encontre o endereço IP externo de um dos nós do cluster.

  1. Acesse o menu do Google Kubernetes Engine no Console do GCP.

    Acesse o menu do Google Kubernetes Engine

  2. Clique no nome do cluster que você está usando para este exercício.

  3. Em Pools de nós, clique no nome do grupo de instâncias. Uma lista de nós será exibida. Anote o endereço IP externo de um dos nós.

Acesse o serviço

Na barra de endereços do navegador, insira [NODE_IP_ADDRESS]:[NODE_PORT].

em que:

  • [NODE_IP_ADDRESS] é o endereço IP externo de um dos nós.
  • [NODE_PORT] é o valor da porta do nó.

A resposta mostra a saída do hello-app:

Hello, world!
Version: 2.0.0
Hostname: service-how-to-50000-695955857d-q76pb

Como criar um serviço do tipo LoadBalancer

kubectl apply

Veja aqui o manifesto de uma implantação:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment-50001
spec:
  selector:
    matchLabels:
      app: products
      department: sales
  replicas: 3
  template:
    metadata:
      labels:
        app: products
        department: sales
    spec:
      containers:
      - name: hello
        image: "gcr.io/google-samples/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50001"

Os contêineres nesta implantação escutarão a porta 50001.

Copie o manifesto para um arquivo denominado my-deployment-50001.yaml e crie a implantação:

kubectl apply -f my-deployment-50001.yaml

Verifique se três pods estão em execução:

kubectl get pods

Veja aqui um manifesto de um serviço do tipo LoadBalancer:

apiVersion: v1
kind: Service
metadata:
  name: my-lb-service
spec:
  type: LoadBalancer
  selector:
    app: products
    department: sales
  ports:
  - protocol: TCP
    port: 60000
    targetPort: 50001

Copie o manifesto para um arquivo chamado my-lb-service.yaml, e crie o serviço:

kubectl apply -f my-lb-service.yaml

Ao criar um serviço do tipo LoadBalancer, um controlador do Google Cloud ativa e configura um balanceador de carga de rede. Aguarde um minuto para o controlador configurar o balanceador de carga de rede e gerar um endereço IP estável.

Visualize o serviço:

kubectl get service my-lb-service --output yaml

A saída mostra um endereço IP externo estável em loadBalancer:ingress:

...
spec:
  ...
  ports:
  - ...
    port: 60000
    protocol: TCP
    targetPort: 50001
  selector:
    app: products
    department: sales
  sessionAffinity: None
  type: LoadBalancer
status:
  loadBalancer:
    ingress:
    - ip: 203.0.113.10

Console

Criar uma implantação

  1. Visite o menu "Cargas de trabalho" do Google Kubernetes Engine no Console do GCP.

    Acessar o menu "Cargas de trabalho"

  2. Clique em Implantar.

  3. Na caixa Contêiner, em Imagem do contêiner, digite gcr.io/google-samples/hello-app:2.0. Clique em Adicionar variáveis de ambiente. Em Chave, digite PORT. Em Valor, digite 50001. Clique em Concluir.

  4. Em Nome do aplicativo, digite my-deployment-50001.

  5. Em Rótulos, crie dois rótulos. Em um deles, defina a Chave como app e o Valor como products. No outro, defina a Chave como department e o Valor como sales.

  6. No menu suspenso Cluster, escolha o cluster que quiser.

  7. Clique em Implantar.

  8. Quando a implantação estiver pronta, a página Detalhes da implantação abrirá e será possível ver que ela conta com um ou mais pods em execução.

Crie um serviço para expor a implantação

  1. Na página Detalhes da implantação, clique em Expor.

  2. Na caixa Novo mapeamento de porta, defina a Porta como 60000 e a Porta de destino como 50001. Deixe o Protocolo definido como TCP e clique em Concluir.

  3. No menu suspenso Tipo de serviço, selecione Balanceador de carga.

  4. Em Nome do serviço, digite my-lb-service.

  5. Clique em Expor.

  6. Quando o serviço estiver pronto, a página Detalhes do serviço abrirá para que você veja os detalhes. Veja o endereço IP externo do balanceador de carga. Anote o endereço IP do balanceador de carga para uso posterior.

Acesse o serviço

Aguarde alguns minutos para o GKE configurar o balanceador de carga.

Na barra de endereços do seu navegador, digite [LOAD_BALANCER_ADDRESS]:60000.

em que [LOAD_BALANCER_ADDRESS] é o endereço IP externo do seu balanceador de carga.

A resposta mostra a saída do hello-app:

Hello, world!
Version: 2.0.0
Hostname: service-how-to-50001-644f8857c7-xxdwg

Observe que o valor da port em um serviço é arbitrário. O exemplo anterior demonstra isso usando um valor de port de 60000.

Como criar um serviço do tipo ExternalName

Um serviço do tipo ExternalName fornece um alias interno para um nome DNS externo. Clientes internos fazem solicitações usando o nome DNS interno e as solicitações são redirecionadas para o nome externo.

Veja aqui um manifesto de um serviço do tipo ExternalName:

apiVersion: v1
kind: Service
metadata:
  name: my-xn-service
spec:
  type: ExternalName
  externalName: example.com

No exemplo anterior, o nome do DNS é my-xn-service.default.svc.cluster.local. Quando um cliente interno faz uma solicitação para esse DNS, ela é redirecionada para example.com.

Como usar o kubectl expose para criar um serviço

Em vez de escrever um manifesto de serviço, é possível criar um serviço usando kubectl expose para expor uma implantação.

Para expor my-deployment, mostrada anteriormente neste tópico, insira este comando:

kubectl expose deployment my-deployment --name my-cip-service \
    --type ClusterIP --protocol TCP --port 80 --target-port 8080

Para expor my-deployment-50000, mostrada anteriormente neste tópico, insira este comando:

kubectl expose deployment my-deployment-50000 --name my-np-service \
    --type NodePort --protocol TCP --port 80 --target-port 50000

Para expor my-deployment-50001, mostrada anteriormente neste tópico, insira este comando:

kubectl expose deployment my-deployment-50001 --name my-lb-service \
    --type LoadBalancer --port 60000 --target-port 50001

Como fazer a limpeza

Depois de concluir os exercícios nesta página, siga estas etapas para remover os recursos e evitar cobranças indesejadas na conta:

kubectl apply

Como excluir serviços

kubectl delete services my-cip-service my-np-service my-lb-service

Como excluir implantações

kubectl delete deployments my-deployment my-deployment-50000 my-deployment-50001

Como excluir a regra de firewall

gcloud compute firewall-rules delete test-node-port

Console

Como excluir serviços

  1. Acesse o menu "Serviços" do Google Kubernetes Engine no Console do GCP.

    Acessar o menu "Serviços"

  2. Clique em meu-cip-service e em Excluir.

  3. Clique em meu-np-service e em Excluir.

  4. Clique em my-lb-service e em Excluir.

Como excluir implantações

  1. Visite o menu "Cargas de trabalho" do Google Kubernetes Engine no Console do GCP.

    Acessar o menu "Cargas de trabalho"

  2. Clique em my-deployment e em Excluir. Deixe a caixa Excluir my-deployment-hpa do autoescalador do pod horizontal selecionada e clique em Excluir.

  3. Clique em my-deployment-50000 e em Excluir. Deixe a caixa Excluir my-deployment-50000-hpa do autoescalador do pod horizontal selecionada e clique em Excluir.

  4. Clique em my-deployment-50001 e em Excluir. Deixe a caixa Excluir my-deployment-50001-hpa do autoescalador do pod horizontal selecionada e clique em Excluir.

Como excluir a regra de firewall

  1. Acesse o menu Regras de firewall no Console do GCP.

    Acessar o menu "Regras de firewall"

  2. Clique em test-node-port e em Excluir.

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Kubernetes Engine