Expor aplicações através de serviços

Esta página mostra como tornar as suas aplicações acessíveis a partir da sua rede interna ou da Internet, criando serviços do Kubernetes no Google Kubernetes Engine (GKE) para expor essas aplicações. Abrange cinco tipos de serviços: ClusterIP, NodePort, LoadBalancer, ExternalName e Headless.

O tutorial inclui exemplos para cada tipo de serviço, mostrando como criar implementações, expô-las através de serviços e aceder às mesmas.

Esta página destina-se a operadores e programadores que preparam e configuram recursos na nuvem, e implementam apps e serviços. Para saber mais sobre as funções comuns e as tarefas de exemplo referenciadas no Trusted Cloud by S3NS conteúdo, consulte o artigoFunções e tarefas comuns do utilizador do GKE.

Antes de ler esta página, certifique-se de que sabe como usar o kubectl.

Introdução

A ideia de um serviço é agrupar um conjunto de pontos finais de agrupamentos num único recurso. Pode configurar várias formas de aceder ao agrupamento. Por predefinição, recebe um endereço IP de cluster estável que os clientes no interior do cluster podem usar para contactar os Pods no serviço. Um cliente envia um pedido para o endereço IP estável e o pedido é encaminhado para um dos agrupamentos no serviço.

Existem cinco tipos de serviços:

  • ClusterIP (predefinição)
  • NodePort
  • LoadBalancer
  • ExternalName
  • Sem interface

Por predefinição, os clusters do Autopilot são públicos. Se optar por um cluster do Autopilot privado, tem de configurar o Cloud NAT para fazer ligações à Internet de saída, por exemplo, extrair imagens do DockerHub.

Este tópico tem vários exercícios. Em cada exercício, cria uma implementação e expõe os respetivos pods criando um serviço. Em seguida, envia um pedido HTTP para o serviço.

Antes de começar

Antes de começar, certifique-se de que realizou as seguintes tarefas:

  • Ative a API Google Kubernetes Engine.
    • Ative a API Google Kubernetes Engine
  • Se quiser usar a CLI gcloud para esta tarefa, instale-a e, em seguida, inicialize-a. Se instalou anteriormente a CLI gcloud, execute gcloud components update para obter a versão mais recente.
  • Certifique-se de que tem um cluster do Autopilot ou Standard existente. Para criar um novo cluster, consulte o artigo Crie um cluster do Autopilot.

Criar um serviço do tipo ClusterIP

Nesta secção, cria um serviço do tipo ClusterIP.

kubectl apply

Segue-se um manifesto para uma implementaçã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: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"

Copie o manifesto para um ficheiro com o nome my-deployment.yaml e crie a implementação:

kubectl apply -f my-deployment.yaml

Verifique se estão a ser executados três pods:

kubectl get pods

O resultado mostra três pods em execução:

NAME                            READY   STATUS    RESTARTS   AGE
my-deployment-dbd86c8c4-h5wsf   1/1     Running   0          7s
my-deployment-dbd86c8c4-qfw22   1/1     Running   0          7s
my-deployment-dbd86c8c4-wt4s6   1/1     Running   0          7s

Segue-se um manifesto para um serviço do tipo ClusterIP:

apiVersion: v1
kind: Service
metadata:
  name: my-cip-service
spec:
  type: ClusterIP
  # Uncomment the below line to create a Headless Service
  # clusterIP: None
  selector:
    app: metrics
    department: sales
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8080

O serviço tem um seletor que especifica duas etiquetas:

  • app: metrics
  • department: sales

Cada Pod na implementação que criou anteriormente tem essas duas etiquetas. Assim, os pods na implementação tornam-se membros deste serviço.

Copie o manifesto para um ficheiro denominado 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, veja o serviço:

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

A saída mostra um valor para clusterIP:

spec:
  clusterIP: 10.59.241.241

Tome nota do valor de clusterIP para mais tarde.

Consola

Crie uma implementação

  1. Aceda à página Workloads na Trusted Cloud consola.

    Aceda a Cargas de trabalho

  2. Clique em Implementar.

  3. Em Especificar contentor, selecione Imagem de contentor existente.

  4. Para Caminho da imagem, introduza us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0

  5. Clique em Concluído e, de seguida, em Continuar.

  6. Em Configuração, para Nome da aplicação, introduza my-deployment.

  7. Em Etiquetas, crie as seguintes etiquetas:

    • Chave: app e Valor: metrics
    • Chave: department e Valor: sales

  8. Em Cluster, escolha o cluster no qual quer criar a implementação.

  9. Clique em Implementar.

  10. Quando a implementação estiver pronta, é apresentada a página Detalhes da implementação. Em Pods geridos, pode ver que a sua implementação tem um ou mais pods em execução.

Crie um serviço para expor a sua implementação

  1. Na página Detalhes da implementação, clique em Ações > Expor.

  2. Na caixa de diálogo Expor, em Mapeamento de portas, defina os seguintes valores:

    • Porta: 80
    • Porta de destino: 8080
    • Protocolo: TCP

  3. Na lista pendente Tipo de serviço, selecione IP do cluster.

  4. Clique em Expor.

  5. Quando o serviço estiver pronto, é apresentada a página Detalhes do serviço, e pode ver os detalhes do serviço. Em IP do cluster, tome nota do endereço IP que o Kubernetes atribuiu ao seu serviço. Este é o endereço IP que os clientes internos podem usar para chamar o Serviço.

Aceder ao seu serviço

Apresentar uma lista dos seus Pods de corrida:

kubectl get pods

Na saída, copie um dos nomes de pods que começa por my-deployment.

NAME                            READY   STATUS    RESTARTS   AGE
my-deployment-dbd86c8c4-h5wsf   1/1     Running   0          2m51s

Aceda a uma shell num dos seus contentores em execução:

kubectl exec -it POD_NAME -- sh

Substitua POD_NAME pelo nome de um dos pods em my-deployment.

Na shell, instale o curl:

apk add --no-cache curl

No contentor, faça um pedido ao seu serviço através do endereço IP do cluster e da porta 80. Repare que 80 é o valor do campo port do seu serviço. Esta é a porta que usa como cliente do serviço.

curl CLUSTER_IP:80

Substitua CLUSTER_IP pelo valor de clusterIP no seu serviço.

O seu pedido é encaminhado para um dos pods membros na porta TCP 8080, que é o valor do campo targetPort. Tenha em atenção que cada um dos pods membros do serviço tem de ter um contentor a detetar na porta 8080.

A resposta mostra o resultado de hello-app:

Hello, world!
Version: 2.0.0
Hostname: my-deployment-dbd86c8c4-h5wsf

Para sair da shell para o seu contentor, introduza exit.

Criar um serviço do tipo NodePort

Nesta secção, cria um serviço do tipo NodePort.

kubectl apply

Segue-se um manifesto para uma implementaçã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: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50000"

Repare no objeto env no manifesto. O objeto env especifica que a variável de ambiente PORT para o contentor em execução vai ter um valor de 50000. A aplicação hello-app escuta na porta especificada pela variável de ambiente PORT. Neste exercício, está a indicar ao contentor que deve ouvir na porta 50000.

Copie o manifesto para um ficheiro com o nome my-deployment-50000.yaml e crie a implementação:

kubectl apply -f my-deployment-50000.yaml

Verifique se estão a ser executados três pods:

kubectl get pods

Segue-se um manifesto para 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 ficheiro denominado my-np-service.yaml e crie o serviço:

kubectl apply -f my-np-service.yaml

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

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

Substitua NODE_PORT pelo valor do campo nodePort do seu serviço.

Consola

Crie uma implementação

  1. Aceda à página Workloads na Trusted Cloud consola.

    Aceda a Cargas de trabalho

  2. Clique em Implementar.

  3. Em Especificar contentor, selecione Imagem de contentor existente.

  4. Para Caminho da imagem, introduza us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0.

  5. Clique em Adicionar variável de ambiente.

  6. Em Chave, introduza PORT e, em Valor, introduza 50000.

  7. Clique em Concluído e, de seguida, em Continuar.

  8. Em Configuração, para Nome da aplicação, introduza my-deployment-50000.

  9. Em Etiquetas, crie as seguintes etiquetas:

    • Chave: app e Valor: metrics
    • Chave: department e Valor: engineering

  10. Em Cluster, escolha o cluster no qual quer criar a implementação.

  11. Clique em Implementar.

  12. Quando a implementação estiver pronta, é apresentada a página Detalhes da implementação. Em Pods geridos, pode ver que a sua implementação tem um ou mais pods em execução.

Crie um serviço para expor a sua implementação

  1. Na página Detalhes da implementação, clique em Ações > Expor.

  2. Na caixa de diálogo Expor, em Mapeamento de portas, defina os seguintes valores:

    • Porta: 80
    • Porta de destino: 50000
    • Protocolo: TCP

  3. Na lista pendente Tipo de serviço, selecione Porta do nó.

  4. Clique em Expor.

  5. Quando o serviço estiver pronto, é apresentada a página Detalhes do serviço, e pode ver os detalhes do serviço. Em Portas, tome nota da porta do nó que o Kubernetes atribuiu ao seu serviço.

Crie uma regra de firewall para a porta do nó

  1. Aceda à página Políticas de firewall na Trusted Cloud consola.

    Aceder a Políticas de firewall

  2. Clique em Criar regra de firewall.

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

  4. Na lista pendente Alvos, selecione Todas as instâncias na rede.

  5. Para Intervalos IPv4 de origem, introduza 0.0.0.0/0.

  6. Em Protocolos e portas, selecione Protocolos e portas especificados.

  7. Selecione a caixa de verificação tcp e introduza o valor da porta do nó que anotou.

  8. Clique em Criar.

Obtenha um endereço IP do nó

Encontre o endereço IP externo de um dos seus nós:

kubectl get nodes --output wide

O resultado é semelhante ao seguinte:

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, se tiver ativado nós privados, os nós não têm endereços IP externos.

Aceda ao seu serviço

Na barra de endereço do navegador, introduza o seguinte:

NODE_IP_ADDRESS:NODE_PORT

Substitua o seguinte:

  • NODE_IP_ADDRESS: o endereço IP externo de um dos seus nós, encontrado quando criou o serviço na tarefa anterior.
  • NODE_PORT: o valor da porta do nó.

O resultado é semelhante ao seguinte:

Hello, world!
Version: 2.0.0
Hostname: my-deployment-50000-6fb75d85c9-g8c4f

Criar um serviço do tipo LoadBalancer

Nesta secção, cria um serviço do tipo LoadBalancer.

kubectl apply

Segue-se um manifesto para uma implementaçã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: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50001"

Repare que os contentores nesta implementação vão ouvir na porta 50001.

Copie o manifesto para um ficheiro com o nome my-deployment-50001.yaml e crie a implementação:

kubectl apply -f my-deployment-50001.yaml

Verifique se estão a ser executados três pods:

kubectl get pods

Segue-se um manifesto para 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 ficheiro denominado my-lb-service.yaml, e crie o Service:

kubectl apply -f my-lb-service.yaml

Quando cria um serviço do tipo LoadBalancer, um Trusted Cloud controlador é ativado e configura um balanceador de carga de rede de encaminhamento externo. Aguarde um minuto para que o controlador configure o balanceador de carga de rede de passagem externa e gere um endereço IP estável.

Ver 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

Consola

Crie uma implementação

  1. Aceda à página Workloads na Trusted Cloud consola.

    Aceda a Cargas de trabalho

  2. Clique em Implementar.

  3. Em Especificar contentor, selecione Imagem de contentor existente.

  4. Para Caminho da imagem, introduza us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0.

  5. Clique em Adicionar variável de ambiente.

  6. Em Chave, introduza PORT e, em Valor, introduza 50001.

  7. Clique em Concluído e, de seguida, em Continuar.

  8. Em Configuração, para Nome da aplicação, introduza my-deployment-50001.

  9. Em Etiquetas, crie as seguintes etiquetas:

    • Chave: app e Valor: products
    • Chave: department e Valor: sales

  10. Em Cluster, escolha o cluster no qual quer criar a implementação.

  11. Clique em Implementar.

  12. Quando a implementação estiver pronta, é apresentada a página Detalhes da implementação. Em Pods geridos, pode ver que a sua implementação tem um ou mais pods em execução.

Crie um serviço para expor a sua implementação

  1. Na página Detalhes da implementação, clique em Ações > Expor.

  2. Na caixa de diálogo Expor, em Mapeamento de portas, defina os seguintes valores:

    • Porta: 60000
    • Porta de destino: 50001
    • Protocolo: TCP

  3. Na lista pendente Tipo de serviço, selecione Equilibrador de carga.

  4. Clique em Expor.

  5. Quando o serviço estiver pronto, é apresentada a página Detalhes do serviço, e pode ver os detalhes do serviço. Em Balanceador de carga, tome nota do endereço IP externo do balanceador de carga.

Aceda ao seu serviço

Aguarde alguns minutos para que o GKE configure o equilibrador de carga.

Na barra de endereço do navegador, introduza o seguinte:

LOAD_BALANCER_ADDRESS:60000

Substitua LOAD_BALANCER_ADDRESS pelo endereço IP externo do seu balanceador de carga.

A resposta mostra o resultado de hello-app:

Hello, world!
Version: 2.0.0
Hostname: my-deployment-50001-68bb7dfb4b-prvct

Tenha em atenção que o valor de port num serviço é arbitrário. O exemplo anterior demonstra isto através da utilização de um valor port de 60 000.

Criar um serviço do tipo ExternalName

Nesta secção, cria um serviço do tipo ExternalName.

Um serviço do tipo ExternalName fornece um alias interno para um nome DNS externo. Os clientes internos fazem pedidos através do nome DNS interno e os pedidos são redirecionados para o nome externo.

Segue-se um manifesto para 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 DNS é my-xn-service.default.svc.cluster.local. Quando um cliente interno faz um pedido a my-xn-service.default.svc.cluster.local, o pedido é redirecionado para example.com.

Usar o kubectl expose para criar um serviço

Em alternativa à escrita de um manifesto de serviço, pode criar um serviço usando kubectl expose para expor uma implementação.

Para expor my-deployment, apresentado anteriormente neste tópico, pode introduzir o seguinte comando:

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

Para expor my-deployment-50000, conforme mostrado anteriormente neste tópico, pode introduzir o seguinte 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, apresentado anteriormente neste tópico, pode introduzir o seguinte comando:

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

Veja os seus serviços

Pode ver os serviços que criou na página Serviços na Trusted Cloud consola.

Aceder a Serviços

Em alternativa, também pode ver os seus serviços no App Hub no contexto das funções empresariais que suportam. O App Hub oferece uma vista geral centralizada de todas as suas aplicações e dos serviços associados.

Para ver os seus serviços no App Hub, aceda à página App Hub na Trusted Cloud consola.

Aceda ao App Hub

Enquanto serviço Kubernetes gerido, o GKE envia automaticamente metadados de serviços, especificamente URIs de recursos, para o App Hub sempre que os recursos são criados ou destruídos. Esta ingestão de metadados sempre ativa melhora a experiência de criação e gestão de aplicações no App Hub.

Para mais informações sobre os recursos suportados pelo App Hub, consulte os recursos suportados.

Para saber como configurar o App Hub no seu projeto, consulte o artigo Configure o App Hub.

Limpar

Depois de concluir os exercícios nesta página, siga estes passos para remover recursos e evitar encargos indesejados na sua conta:

kubectl apply

Eliminar os seus serviços

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

Eliminar as suas implementações

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

Eliminar a regra de firewall

gcloud compute firewall-rules delete test-node-port

Consola

Eliminar os seus serviços

  1. Aceda à página Serviços na Trusted Cloud consola.

    Aceder a Serviços

  2. Selecione os serviços que criou neste exercício e, de seguida, clique em Eliminar.

  3. Quando lhe for pedido que confirme, clique em Eliminar.

Eliminar as suas implementações

  1. Aceda à página Workloads na Trusted Cloud consola.

    Aceda a Cargas de trabalho

  2. Selecione as implementações que criou neste exercício e, de seguida, clique em Eliminar.

  3. Quando lhe for pedido para confirmar, selecione a caixa de verificação Eliminar Horizontal Pod Autoscalers associados às implementações selecionadas e, de seguida, clique em Eliminar.

Eliminar a regra de firewall

  1. Aceda à página Políticas de firewall na Trusted Cloud consola.

    Aceder a Políticas de firewall

  2. Selecione a caixa de verificação test-node-port e, de seguida, clique em Eliminar.

  3. Quando lhe for pedido que confirme, clique em Eliminar.

O que se segue?