Como exibir aplicativos usando serviços

Nesta página, você aprenderá a criar Services 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 Service agrupa um conjunto de endpoints de 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 Services:

  • 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

Execute as etapas a seguir para se preparar para a tarefa:

  • Verifique se você ativou a API do Google Kubernetes Engine.
  • Ativar a API do 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 padrão do Compute:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Se você estiver trabalhando com clusters regionais, defina a região padrão do Compute:
    gcloud config set compute/region [COMPUTE_REGION]
  • Atualize gcloud para a versão mais recente:
    gcloud components update

Como criar um serviço do tipo ClusterIP

kubectl apply

Veja 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 um manifesto para um Service 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 Service tem um seletor que especifica dois rótulos:

  • app: metrics
  • department: sales

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

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

kubectl apply -f my-cip-service.yaml

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

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

A saída mostra um valor para clusterIP.

spec:
  clusterIP: 10.59.241.241

Anote o valor do seu clusterIP para mais tarde.

Console

Criar uma implantação

  1. Acesse 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 para Imagem do contêiner, digite gcr.io/google-samples/hello-app:2.0 e clique em Concluído.

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

  5. Em Rótulos, crie dois rótulos. Para um deles, defina Chave como app e Valor como metrics. Para o outro, defina Chave como department e 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 será aberta, e você verá que ela conta com um ou mais pods em execução.

Criar um Service para expor a implantação

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

  2. Na caixa Novo mapeamento da porta, defina a Porta como 80 e a Porta de destino como 8080. Deixe Protocolo definido como TCP. Clique em Concluído.

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

  4. Em Nome do serviço, insira 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 Service. 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 Service

Liste os pods em execução:

kubectl get pods

Na saída, copie um dos nomes 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 em my-deployment.

No seu shell, instale curl:

apk add --no-cache curl

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

curl [CLUSTER_IP]:80

em que [CLUSTER_IP] é o valor de clusterIP em seu Service.

Sua 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 Service precisa ter um contêiner escutando a porta 8080.

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

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

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

Como criar um Service do tipo NodePort

kubectl apply

Veja 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 do contêiner em execução terá um valor de 50000. O aplicativo hello-app detecta atividade na porta especificada pela variável de ambiente PORT. Portanto, neste exercício, você está dizendo ao contêiner para detectar atividade na porta 50.000.

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 Service 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 Service:

kubectl apply -f my-np-service.yaml

Veja o Service:

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 no seu cluster tiverem endereços IP externos, localize o endereço de 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 Service.

Console

Criar uma implantação

  1. Acesse 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, insira 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, insira my-deployment-50000.

  5. Em Rótulos, crie dois rótulos. Para um deles, defina Chave como app e Valor como metrics. Para o outro, defina Chave como department e 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 será aberta, e você verá que ela conta com um ou mais pods em execução.

Criar um Service para expor a implantação

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

  2. Na caixa Novo mapeamento da porta, defina a Porta como 80 e a Porta de destino como 50000. Deixe Protocolo definido como TCP. Clique em Concluído.

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

  4. Em Nome do serviço, insira 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 Service. Anote a Porta do nó para uso posterior.

Criar uma regra de firewall para a porta de 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, insira test-node-port.

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

  5. Em Intervalos de IP de origem, insira 0.0.0.0/0.

  6. Em Portas e protocolos especificados, selecione tcp e insira o valor de porta de 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.

    Acessar 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.

Acessar o Service

Na barra de endereço do seu navegador, digite [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 de nó.

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

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

Como criar um Service 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 um manifesto para um Service 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 Service:

kubectl apply -f my-lb-service.yaml

Quando você cria um Service do tipo LoadBalancer, um controlador do Google Cloud é ativado 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.

Veja o Service:

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. Acesse 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. Clique em Adicionar variáveis de ambiente. Em Chave, digite PORT. Em Valor, digite 50001. Clique em Concluído.

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

  5. Em Rótulos, crie dois rótulos. Para um deles, defina Chave como app e Valor como products. Para o outro, defina Chave como department e 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 será aberta, e você verá que ela conta com um ou mais pods em execução.

Criar um Service para expor a implantação

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

  2. Na caixa Novo mapeamento da porta, defina a Porta como 60000 e a Porta de destino como 50001. Deixe Protocolo definido como TCP. Clique em Concluído.

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

  4. Em Nome do serviço, insira 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.

Acessar o Service

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

Na barra de endereço 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 de hello-app:

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

Observe que o valor de port em um Service é arbitrário. O exemplo anterior demonstra isso usando um valor port de 60.000.

Como criar um Service do tipo ExternalName

Um Service 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 um manifesto para um Service 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 kubectl expose para criar um Service

Como alternativa à gravação de um manifesto de Service, crie um Service usando kubectl expose para expor uma implantação.

Para expor my-deployment, mostrado 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, mostrado 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, mostrado 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 sua conta:

kubectl apply

Como excluir Services

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 Services

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

    Acessar o menu Services

  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. Acesse 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 de autoescalador de pod horizontal selecionada e clique em Excluir.

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

  4. Clique em my-deployment-50001 e em Excluir. Deixe a caixa Excluir my-deployment-50001-hpa de autoescalador de 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