Implantar um aplicativo no GKE na AWS

Esta página fornece instruções de início rápido para criar um cluster e um pool de nós e, em seguida, implantar um aplicativo de exemplo usando o GKE na AWS.

Esta página é para administradores e operadores de TI que desejam configurar, monitorar e gerenciar a infraestrutura de nuvem. Para saber mais sobre funções comuns e tarefas de exemplo que mencionamos em Google Cloud conteúdo, consulte Funções e tarefas comuns do usuário do GKE Enterprise .

Inicie rapidamente seu cluster com o Terraform

Você pode usar o Terraform para criar um cluster e um pool de nós . Antes de criar seu cluster, os scripts do Terraform também preparam sua VPC da AWS.

Você pode aprender mais sobre o Terraform em um ambiente 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, vá para Implantar um aplicativo no cluster para implantar um aplicativo de exemplo.

Inicie seu cluster rapidamente sem o Terraform

Se você preferir preparar sua AWS VPC 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, você deve atender aos pré-requisitos . Em particular, você deve fornecer os seguintes recursos:

• Uma VPC da AWS onde o cluster será executado.
• Até três sub-redes da AWS para as três réplicas do plano de controle. Cada uma deve estar em uma Zona de Disponibilidade da AWS diferente.
• A função do IAM da AWS que o GKE na AWS assume ao gerenciar seu cluster. Isso requer um conjunto específico de permissões do IAM .
• Chaves CMK simétricas do KMS para criptografia em repouso de dados de cluster (etcd) e configuração.
• O perfil da instância do AWS IAM 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 seus clusters do GKE na AWS. Todos os outros recursos subjacentes da AWS no escopo do cluster são gerenciados pelo GKE na AWS.

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

Use o gcloud CLI para configurar as configurações padrão para seu projeto padrão e Google Cloud região.

Seu projeto tem um ID de projeto como identificador exclusivo. Ao criar um projeto, você pode usar o ID de projeto gerado automaticamente ou criar o seu próprio.

Seu Google Cloud região é o local de onde seus clusters serão gerenciados. Por exemplo, us-west1 . Consulte Regiões de gerenciamento para obter mais detalhes.

Ao configurar essas configurações padrão, você não precisa incluí-las ao executar a Google Cloud CLI. Você também pode especificar configurações ou substituí-las passando os sinalizadores --project e --location para a Google Cloud CLI.

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

Para definir padrões, siga estas etapas:

1. Defina o projeto padrão:

   gcloud config set project PROJECT_ID
   

   Substitua PROJECT_ID pelo ID do seu projeto.

2. Defina o local de gerenciamento padrão:

   gcloud config set container_aws/location GOOGLE_CLOUD_LOCATION
   

   Substitua GOOGLE_CLOUD_LOCATION pela sua localização, como us-west1 .

Selecione intervalos CIDR para seu cluster

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

• Intervalo CIDR de endereço de pod : quando um novo Pod é criado, ele recebe um endereço IP desse intervalo. Exemplo de intervalo: 192.168.208.0/20

• Intervalo CIDR de endereço de serviço : quando um novo Service é criado, ele recebe um endereço IP desse intervalo. Exemplo de intervalo: 192.168.224.0/20

Criar um cluster

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

gcloud container aws clusters create aws-cluster-0 \
    --cluster-version 1.31.4-gke.500 \
    --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 o seguinte:

• AWS_REGION : a região da AWS para criar o cluster.
• FLEET_PROJECT_ID : o projeto host da frota onde o cluster será registrado
• VPC_ID : o ID do AWS VPC para este cluster que você configurou na etapa de pré-requisito Criar seu VPC
• CONTROL_PLANE_SUBNET_1 , CONTROL_PLANE_SUBNET_2 , CONTROL_PLANE_SUBNET_3 : as IDs de sub-rede para as três instâncias do plano de controle do seu cluster que você criou na etapa de pré-requisito Criar sub-redes privadas
• POD_CIDR_BLOCK : o intervalo de endereços CIDR para os pods do seu cluster
• SERVICE_CIDR_BLOCK : o intervalo de endereços CIDR para os serviços do seu cluster
• API_ROLE_ARN : o ARN da função do IAM para o serviço GKE Multi-Cloud que você criou na etapa de pré-requisito Criar função de API do GKE Multi-Cloud
• CONTROL_PLANE_PROFILE : o nome do perfil da instância do IAM associada ao cluster que você escolheu na etapa de pré-requisito Criar função do plano de controle
• DB_KMS_KEY_ARN : o nome do recurso da Amazon (ARN) de uma das chaves do AWS KMS que você criou na etapa de pré-requisito Criar uma chave do AWS KMS
• CONFIG_KMS_KEY_ARN : o nome do recurso da Amazon (ARN) da outra chave do AWS KMS que você criou na etapa de pré-requisito Criar uma chave do AWS KMS

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

Criar 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.31.4-gke.500 \
    --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 o seguinte:

• NODEPOOL_SUBNET_ID : o ID de uma das sub-redes privadas que você criou na etapa de pré-requisito Criar sub-redes privadas
• NODEPOOL_PROFILE : o nome do perfil da instância do IAM para as instâncias do EC2 no pool de nós que você escolheu na etapa de pré-requisito Criar uma função do IAM do pool de nós
• CONFIG_KMS_KEY_ARN : o nome do recurso da Amazon (ARN) da chave AWS KMS para criptografar dados do usuário
• EC2_KEY_PAIR (opcional): o nome do par de chaves EC2 criado para acesso SSH (opcional) que você criou na etapa de pré-requisito Criar par de chaves SSH

Visualize o status do seu cluster

Depois de criar um cluster e um pool de nós, você pode visualizar o status de um cluster com o Google Cloud CLI ou o Google Cloud console. Para visualizar o status do cluster, escolha se você está usando o Google Cloud CLI ou Google Cloud console e siga estes passos:

gcloud container aws clusters describe CLUSTER_NAME \
    --location GOOGLE_CLOUD_LOCATION

Obter credenciais de autenticação para o cluster

Depois de criar seu cluster, você precisa obter credenciais de autenticação para interagir com o cluster:

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

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

Implantar um aplicativo no cluster

Agora que você criou um cluster, pode implantar um aplicativo em contêiner nele. Para este início rápido, você pode implantar nosso aplicativo web de exemplo, hello-app .

Use objetos do Kubernetes para criar e gerenciar os recursos do seu cluster. Use o objeto Deployment para implantar aplicativos sem estado, como servidores web. Objetos de serviço definem regras e balanceadores de carga para acessar seu aplicativo pela internet.

Criar a implantação

Para executar hello-app no ​​seu 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 .

Neste 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 . O comando :1.0 indica a versão específica da imagem a ser extraída. Se você não especificar uma versão, a imagem marcada com latest será usada.

Exponha a implantação

Após implantar o aplicativo, você precisa expô-lo à 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 o sinalizador --type LoadBalancer cria um balanceador de carga da AWS para o seu contêiner. O sinalizador --port inicializa a porta pública 80 para a internet e o sinalizador --target-port roteia 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 visualizar o aplicativo

1. Inspecione os Pods em execução usando kubectl get pods :

   kubectl get pods
   

   Você deverá ver um Pod hello-server em execução no seu cluster.

2. Inspecione o serviço hello-server usando kubectl get service :

   kubectl get service hello-server
   

   A partir da saída deste comando, copie o endereço IP externo do serviço da coluna EXTERNAL-IP .

3. Visualize o aplicativo no seu navegador da web usando o IP externo com a porta exposta:

   http://EXTERNAL-IP
   

Você acabou de implantar um aplicativo web em contêiner no GKE na AWS.

Limpar

1. Exclua o Serviço e a Implantação do aplicativo:

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

2. Exclua seu pool de nós executando gcloud container aws node-pools delete :

   gcloud container aws node-pools delete pool-0 --cluster aws-cluster-0
   

3. Exclua seu cluster executando gcloud container aws clusters delete :

   gcloud container aws clusters delete aws-cluster-0
   

O que vem a seguir

• Instalar o Anthos Config Management