Esta documentação é referente à versão atual do GKE na AWS, lançada em novembro de 2021. Consulte as Notas de lançamento para mais informações.

Esta página foi traduzida pela API Cloud Translation.

Implantar um aplicativo no GKE na AWS

Nesta página, fornecemos instruções de início rápido para criar um cluster e um pool de nós e implantar um aplicativo de amostra usando o GKE na AWS.

Guia de início rápido do cluster com o Terraform

É possível usar o Terraform para criar um cluster e um pool de nós. Antes de criar o cluster, os scripts do Terraform também preparam a VPC da AWS.

Saiba mais sobre o Terraform em um ambiente da AWS na referência do cluster do Terraform e na referência do pool de nós do Terraform.

Depois de criar uma VPC e um cluster com o Terraform, pule para Implantar um aplicativo no cluster para implantar um aplicativo de amostra.

Guia de início rápido do cluster sem o Terraform

Se você preferir preparar a VPC da AWS e criar um cluster e um pool de nós sem o Terraform, siga estas instruções.

Antes de começar

Antes de criar um cluster, conclua os pré-requisitos. Especificamente, é necessário fornecer os seguintes recursos:

Uma VPC da AWS em que o cluster será executado.
Até três sub-redes da AWS para as três réplicas do plano de controle. Cada um precisa estar em uma zona de disponibilidade diferente da AWS.
O papel do IAM da AWS que o GKE na AWS assume ao gerenciar o cluster. Isso requer um conjunto específico de permissões do IAM.
Chaves CMK simétricas do KMS para criptografia e configuração de dados do cluster (etcd) em repouso.
O perfil da instância do IAM da AWS para cada réplica do plano de controle. Isso requer um conjunto específico de permissões do IAM.
Um par de chaves SSH do EC2 (opcional) se você precisar de acesso SSH às instâncias do EC2 que executam cada réplica do plano de controle.

É sua responsabilidade criar e gerenciar esses recursos, que podem ser compartilhados entre todos os clusters do GKE na AWS. Todos os outros recursos da AWS com escopo de cluster são gerenciados pelo GKE na AWS.

Definir as configurações padrão para a CLI gcloud

Use a CLI gcloud para definir as configurações padrão do projeto padrão e da região do Google Cloud.

O projeto tem um ID como identificador exclusivo. Ao criar um projeto, é possível usar o ID do projeto gerado automaticamente ou criar um próprio.

Sua região do Google Cloud é um local onde os clusters serão gerenciados. Por exemplo, us-west1 Consulte as regiões de gerenciamento para mais detalhes.

Ao definir essas configurações padrão, não é necessário incluí-las ao executar a Google Cloud CLI. Também é possível especificar configurações ou modificar as configurações padrão transmitindo as sinalizações --project e --location para a Google Cloud CLI.

Quando você cria o GKE nos recursos da AWS depois de configurar o projeto e o local padrão, os recursos são criados automaticamente nesse projeto e local.

Para definir os padrões, siga estas etapas:

Defina o projeto padrão.
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pela ID do seu projeto.
Defina o local de gerenciamento padrão:
```
gcloud config set container_aws/location GOOGLE_CLOUD_LOCATION
```
Substitua GOOGLE_CLOUD_LOCATION pela sua localização, por exemplo, us-west1.

Selecionar intervalos CIDR para o cluster

O Kubernetes exige que dois intervalos de CIDR sejam fornecidos para o cluster. Esses intervalos de CIDR precisam ser escolhidos para que não se sobreponham aos intervalos de CIDR usados pelas sub-redes VPC. Eles precisam ser grandes o suficiente para o tamanho máximo esperado do cluster.

Intervalo de CIDR do endereço do pod: quando um novo Pod é criado, ele recebe um endereço IP desse intervalo. Exemplo de intervalo: 192.168.208.0/20
Intervalo de CIDR do endereço do serviço: quando um novo Service é criado, um endereço IP desse intervalo é alocado para ele. Exemplo de intervalo: 192.168.224.0/20

Criar um cluster

Use o seguinte comando para criar um cluster no GKE na AWS. Para mais informações sobre esse comando, incluindo os parâmetros opcionais, consulte a página de referência de gcloud container aws create.

gcloud container aws clusters create aws-cluster-0 \
    --cluster-version 1.29.3-gke.600 \
    --aws-region AWS_REGION \
    --fleet-project FLEET_PROJECT_ID \
    --vpc-id VPC_ID \
    --subnet-ids CONTROL_PLANE_SUBNET_1,CONTROL_PLANE_SUBNET_2,CONTROL_PLANE_SUBNET_3 \
    --pod-address-cidr-blocks POD_CIDR_BLOCK \
    --service-address-cidr-blocks SERVICE_CIDR_BLOCK \
    --role-arn API_ROLE_ARN \
    --iam-instance-profile CONTROL_PLANE_PROFILE \
    --database-encryption-kms-key-arn DB_KMS_KEY_ARN \
    --config-encryption-kms-key-arn CONFIG_KMS_KEY_ARN \
    --tags "google:gkemulticloud:cluster=aws-cluster-0"

Substitua:

AWS_REGION: a região da AWS em que o cluster será criado.
FLEET_PROJECT_ID: o projeto host da frota em que o cluster será registrado.
VPC_ID: o ID da VPC da AWS para este cluster que você configurou na etapa de pré-requisito Criar sua VPC.
CONTROL_PLANE_SUBNET_1, CONTROL_PLANE_SUBNET_2, CONTROL_PLANE_SUBNET_3: os IDs de sub-rede das três instâncias do plano de controle do cluster que você criou na etapa de pré-requisito Criar sub-redes particulares.
POD_CIDR_BLOCK: o intervalo de endereços CIDR dos pods do cluster.
SERVICE_CIDR_BLOCK o intervalo de endereços CIDR dos serviços do cluster.
API_ROLE_ARN: o ARN do papel do IAM do serviço de várias nuvens do GKE que você criou na etapa de pré-requisito Criar papel da API GKE Multi-Cloud.
CONTROL_PLANE_PROFILE: o nome do perfil da instância do IAM associada ao cluster escolhido na etapa de pré-requisito Criar papel do plano de controle.
DB_KMS_KEY_ARN: o nome do Recurso da Amazon (ARN, na sigla em inglês) de uma das chaves KMS da AWS que você criou na etapa de pré-requisito Criar uma chave KMS da AWS;
CONFIG_KMS_KEY_ARN: o nome de recurso da Amazon (ARN) das outras chaves de KMS da AWS que você criou na etapa de pré-requisito Criar uma chave de AWS KMS;

Se estiver presente, o parâmetro --tags aplicará a tag da AWS fornecida a todos os recursos subjacentes da AWS gerenciados pelo GKE na AWS. Este exemplo marca os nós do plano de controle com o nome do cluster ao qual eles pertencem.

Crie um pool de nós.

Use o seguinte comando para criar um pool de nós:

gcloud container aws node-pools create pool-0 \
    --cluster aws-cluster-0 \
    --node-version 1.29.3-gke.600 \
    --min-nodes 1 \
    --max-nodes 5 \
    --max-pods-per-node 110 \
    --root-volume-size 50 \
    --subnet-id NODEPOOL_SUBNET_ID \
    --iam-instance-profile NODEPOOL_PROFILE \
    --config-encryption-kms-key-arn CONFIG_KMS_KEY_ARN \
    --ssh-ec2-key-pair EC2_KEY_PAIR \
    --tags "google:gkemulticloud:cluster=aws-cluster-0"

Substitua:

NODEPOOL_SUBNET_ID: o ID de uma das sub-redes particulares que você criou na etapa de pré-requisito Criar sub-redes particulares.
NODEPOOL_PROFILE: o nome do perfil da instância do IAM para as instâncias do EC2 no pool de nós escolhido na etapa de pré-requisito Criar um papel do IAM de pool de nós.
CONFIG_KMS_KEY_ARN: o Nome de Recursos da Amazon (ARN, na sigla em inglês) da chave de AWS KMS para criptografar dados do usuário;
EC2_KEY_PAIR (opcional): o nome do par de chaves do EC2 criado para o acesso SSH (opcional) criado na etapa de pré-requisito Criar par de chaves SSH.

Ver o status do cluster

Depois de criar um cluster e um pool de nós, é possível ver o status de um cluster com a Google Cloud CLI ou o console do Google Cloud. Para ver o status do cluster, escolha se você está usando a Google Cloud CLI ou o console do Google Cloud e siga estas etapas:

gcloud

Use o comando gcloud container aws clusters describe para ver detalhes sobre o cluster:

gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION

Substitua:

CLUSTER_NAME: o nome do cluster.
GOOGLE_CLOUD_LOCATION: o nome do local do Google Cloud que gerencia o cluster

Console do Google Cloud

No console do Google Cloud, acesse a página Visão geral dos clusters do Google Kubernetes Engine.

Acesse os clusters do GKE
Os clusters são listados por nome e local.
Clique no nome do cluster. Será exibido um painel com informações sobre o cluster, incluindo o status e os recursos ativados.

receba as credenciais de autenticação para o cluster

Depois de criar o cluster, você precisará das credenciais de autenticação para interagir com o cluster:

gcloud container aws clusters get-credentials aws-cluster-0

Esse comando configura kubectl para acessar o cluster que você criou pelo Gateway do Connect. Você precisa de pelo menos um pool de nós para usar o gateway do Connect porque ele depende do agente do Connect, que é executado como uma implantação no cluster.

Implantar um aplicativo no cluster

Agora que criou um cluster, é possível implantar um aplicativo conteinerizado nele. Para este guia de início rápido, implante nosso aplicativo da Web de exemplo, hello-app.

Você usa objetos do Kubernetes para criar e gerenciar os recursos do cluster. Use o objeto de implantação para implantar aplicativos sem estado, como servidores da Web. Os objetos de Serviço definem as regras e os balanceadores de carga para acessar o aplicativo pela Internet.

Criar a implantação

Para executar hello-app no cluster, você precisa implantar o aplicativo executando o seguinte comando:

kubectl create deployment hello-server --image=us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0

Este comando do Kubernetes, kubectl create deployment, cria uma implantação chamada hello-server. O pod da implantação executa a imagem do contêiner hello-app.

Nesse comando:

--image especifica uma imagem de contêiner a ser implantada. Nesse caso, o comando extrai a imagem de exemplo de um repositório do Artifact Registry, us-docker.pkg.dev/google-samples/containers/gke/hello-app. :1.0 indica a versão da imagem específica a ser extraída. Se você não especificar uma versão, a imagem marcada com latest será usada.

Expor a implantação

Após a implantação do aplicativo, você precisará expô-lo na Internet para que os usuários possam acessá-lo. Você pode expor seu aplicativo criando um serviço, um recurso do Kubernetes que expõe seu aplicativo ao tráfego externo.

Para expor seu aplicativo, execute o seguinte comando kubectl expose:

kubectl expose deployment hello-server --type LoadBalancer --port 80 --target-port 8080

Passar na sinalização --type LoadBalancer cria um balanceador de carga da AWS para seu contêiner. A sinalização --port inicializa a porta pública 80 na Internet e a sinalização --target-port encaminha o tráfego para a porta 8080 do aplicativo.

Os balanceadores de carga são cobrados de acordo com os preços do balanceador de carga da AWS.

Inspecionar e ver o aplicativo

Inspecione os pods em execução usando kubectl get pods:
```
kubectl get pods
```
Você verá um pod hello-server em execução no cluster.
Use kubectl get service para inspecionar o serviço hello-server:
```
kubectl get service hello-server
```
Na saída desse comando, copie o endereço IP externo do serviço da coluna EXTERNAL-IP.

Observação: talvez você precise aguardar vários minutos até que o endereço IP externo do serviço fique disponível. Se o IP externo do aplicativo for <pending>, execute kubectl get service novamente.
Use o IP externo com a porta exposta a seguir para ver o aplicativo pelo navegador da Web:
```
http://EXTERNAL-IP
```

Você acabou de implantar um aplicativo da Web conteinerizado no GKE na AWS.

Limpar

Exclua o Serviço e a implantação do aplicativo:

kubectl delete service hello-server
kubectl delete deployment hello-server

Execute gcloud container aws node-pools delete para excluir o pool de nós:
```
gcloud container aws node-pools delete pool-0 --cluster aws-cluster-0
```
Execute gcloud container aws clusters delete para excluir o cluster:
```
gcloud container aws clusters delete aws-cluster-0
```

A seguir

Instale o Anthos Config Management