The product described by this documentation, Anthos Clusters on AWS (previous generation), is now in maintenance mode. All new installs must use the current generation product, Anthos clusters on AWS.

Como criar um cluster de usuário personalizado

Este tópico descreve como personalizar a configuração de um GKE no cluster de usuário da AWS.

Convém criar um cluster de usuário personalizado pelos seguintes motivos:

Criar outro cluster para um ambiente de preparo ou teste.
Como adicionar pools de nós com diferentes tipos de máquinas.
A criação de um cluster em zonas de disponibilidade específicas da AWS (AZ).

Antes de começar

Antes de começar a usar o GKE na AWS, verifique se você executou as seguintes tarefas:

Conclua os Pré-requisitos.

Instale um serviço de gerenciamento.
Se você quiser criar um cluster sem usar terraform output example_cluster, tenha sub-redes particulares da AWS para seu plano de controle. Cada sub-rede precisa pertencer a um AZ diferente na mesma região da AWS. As tabelas de rota precisam ser configuradas para permitir o tráfego entre sub-redes particulares. Além disso, cada sub-rede precisa ter acesso a um gateway NAT.
Tenha seu código de nuvem privada virtual (VPC) da AWS. Um ID de VPC é semelhante a vpc-012345678abcde. É possível encontrar o ID da VPC no Console da AWS.

Para se conectar ao GKE nos recursos da AWS, execute as etapas a seguir. Selecione se você tem uma VPC atual da AWS (ou conexão direta com a VPC) ou criou uma VPC dedicada ao criar seu serviço de gerenciamento.

VPC atual

Se você tiver uma conexão direta ou VPN com uma VPC atual, omita a linha env HTTP_PROXY=http://localhost:8118 dos comandos neste tópico.

VPC dedicada

Quando você cria um serviço de gerenciamento em uma VPC dedicada, o GKE na AWS inclui um bastion host em uma sub-rede pública.

Para se conectar ao serviço de gerenciamento, siga estas etapas:

Mude para o diretório com o GKE na configuração da AWS. Você criou esse diretório ao instalar o serviço de gerenciamento.
```
cd anthos-aws
```
Para abrir o túnel, execute o script bastion-tunnel.sh. O túnel encaminha para localhost:8118.

Para abrir um túnel para o Bastion Host, execute o seguinte comando:
```
./bastion-tunnel.sh -N
```
As mensagens do túnel SSH aparecem nessa janela. Quando estiver pronto para fechar a conexão, interrompa o processo usando Control+C ou fechando a janela.
Abra um novo terminal e mude para o diretório anthos-aws.
```
cd anthos-aws
```
Verifique se você consegue se conectar ao cluster com kubectl.
```
env HTTPS_PROXY=http://localhost:8118 \
kubectl cluster-info
```
A saída inclui o URL do servidor da API de serviço de gerenciamento.

Como selecionar um tamanho de instância do plano de controle

O GKE na AWS não é compatível com o redimensionamento de instâncias do plano de controle. Antes de criar seu cluster de usuário, selecione o tamanho da instância dos planos de controle. Os tamanhos do plano de controle dependem do número de nós no cluster. A tabela a seguir contém os tamanhos de instância do plano de controle recomendados para vários tamanhos de cluster.

Tamanho do cluster (nós)	Tipo de instância do plano de controle
1 – 10	m5.large
11 – 100	m5.xlarge
101 – 200	m5.2xlarge

Como criar um novo cluster com uma configuração personalizada

Use terraform output example_cluster para criar uma configuração para um cluster de usuário por cluster de gerenciamento. Se você quiser criar outros clusters, aplique uma configuração personalizada.

Neste exemplo, você cria um cluster manualmente a partir de CRDs AWSCluster e AWSNodePool.

Mude para o diretório com o GKE na configuração da AWS. Você criou esse diretório ao instalar o serviço de gerenciamento.
```
cd anthos-aws
```
No diretório anthos-aws, use anthos-gke para alternar o contexto para o serviço de gerenciamento.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Observação: anthos-gke usa as credenciais especificadas quando você executou aws configure.
Abra um editor de texto e copie a seguinte definição AWSCluster em um arquivo chamado custom-cluster.yaml.
```
apiVersion: multicloud.cluster.gke.io/v1
kind: AWSCluster
metadata:
  name: CLUSTER_NAME
spec:
  region: AWS_REGION
  networking:
    vpcID: VPC_ID
    podAddressCIDRBlocks: POD_ADDRESS_CIDR_BLOCKS
    serviceAddressCIDRBlocks: SERVICE_ADDRESS_CIDR_BLOCKS
    ServiceLoadBalancerSubnetIDs: SERVICE_LOAD_BALANCER_SUBNETS
  controlPlane:
    version:  CLUSTER_VERSION # Latest version is 1.25.5-gke.2100
    instanceType: AWS_INSTANCE_TYPE
    keyName: SSH_KEY_NAME
    subnetIDs:
    - CONTROL_PLANE_SUBNET_IDS
    securityGroupIDs:
    - CONTROL_PLANE_SECURITY_GROUPS
    iamInstanceProfile: CONTROL_PLANE_IAM_ROLE
    rootVolume:
      sizeGiB: ROOT_VOLUME_SIZE
      volumeType: ROOT_VOLUME_TYPE # Optional
      iops: ROOT_VOLUME_IOPS # Optional
      kmsKeyARN: ROOT_VOLUME_KEY # Optional
    etcd:
      mainVolume:
        sizeGiB: ETCD_VOLUME_SIZE
        volumeType: ETCD_VOLUME_TYPE # Optional
        iops: ETCD_VOLUME_IOPS # Optional
        kmsKeyARN: ETCD_VOLUME_KEY # Optional
    databaseEncryption:
      kmsKeyARN: ARN_OF_KMS_KEY
    hub: # Optional
      membershipName: ANTHOS_CONNECT_NAME
    cloudOperations: # Optional
      projectID: YOUR_PROJECT
      location: GCP_REGION
      enableLogging: ENABLE_LOGGING
      enableMonitoring: ENABLE_MONITORING
    workloadIdentity: # Optional
      oidcDiscoveryGCSBucket: WORKLOAD_IDENTITY_BUCKET
```
Substitua:
- CLUSTER_NAME: o nome do cluster.
- AWS_REGION: a região da AWS em que o cluster é executado.
  
  Observação: é preciso criar o cluster de usuário na mesma região do serviço de gerenciamento.
- VPC_ID: O ID da VPC em que o cluster é executado.
- POD_ADDRESS_CIDR_BLOCKS: o intervalo de endereços IPv4 usados pelos pods do cluster. Atualmente, apenas um intervalo é aceito. O intervalo não pode se sobrepor a nenhuma sub-rede acessível pela rede. É seguro usar o mesmo intervalo em vários objetos diferentes do AWSCluster. Por exemplo, 10.2.0.0/16.
- SERVICE_ADDRESS_CIDR_BLOCKS: o intervalo de endereços IPv4 usados pelos serviços do cluster; Atualmente, apenas um intervalo é aceito. O intervalo não pode se sobrepor a nenhuma sub-rede acessível pela rede. É seguro usar o mesmo intervalo em vários objetos diferentes do AWSCluster. Por exemplo, 10.1.0.0/16.
- SERVICE_LOAD_BALANCER_SUBNETS: os IDs de sub-rede em que o GKE na AWS pode criar balanceadores de carga públicos ou particulares.
- CLUSTER_VERSION: uma versão do Kubernetes (em inglês) compatível com o GKE na AWS. A versão mais recente é 1.25.5-gke.2100.
- AWS_INSTANCE_TYPE: um tipo de instância EC2 compatível.
- SSH_KEY_NAME: um par de chaves do AWS EC2.
- CONTROL_PLANE_SUBNET_IDS: os IDs de sub-rede nos AZs em que suas instâncias do plano de controle são executadas.
- CONTROL_PLANE_SECURITY_GROUPS: um securityGroupID criado durante a instalação do serviço de gerenciamento. É possível personalizar isso adicionando qualquer securityGroupID necessário para se conectar ao plano de controle.
- CONTROL_PLANE_IAM_PROFILE: nome do perfil da instância do AWS EC2 atribuído às réplicas do plano de controle.
- ROOT_VOLUME_SIZE: o tamanho, em gibibyte (GiB), dos volumes raiz do seu plano de controle.
- ROOT_VOLUME_TYPE pelo tipo de volume EBS. Por exemplo, gp3.
- ROOT_VOLUME_IOPS pela quantidade de operações de E/S provisionadas por segundo (IOPS, na sigla em inglês) para o volume. Válido apenas quando volumeType for GP3. Para mais informações, consulte Volumes SSD de uso geral (gp3).
- ROOT_VOLUME_KEY pelo nome de recurso da Amazon da chave de KMS da AWS que criptografa os volumes raiz da instância do plano de controle.
- ETCD_VOLUME_SIZE: o tamanho dos volumes usados pelo etcd.
- ETCD_VOLUME_TYPE pelo tipo de volume EBS. Por exemplo, gp3.
- ETCD_VOLUME_IOPS pela quantidade de operações de E/S provisionadas por segundo (IOPS, na sigla em inglês) para o volume. Válido apenas quando volumeType for gp3. Para mais informações, consulte Volumes SSD de uso geral (gp3).
- ETCD_VOLUME_KEY pelo nome de recurso da Amazon da chave de KMS da AWS que criptografa os volumes de dados etcd do plano de controle etc.
- ARN_OF_KMS_KEY: a chave do AWS KMS usada para criptografar secrets do cluster.
- O nome da assinatura do ANTHOS_CONNECT_NAMEConnect usado para registrar seu cluster. O nome da assinatura precisa ser exclusivo. Por exemplo, projects/YOUR_PROJECT/locations/global/memberships/CLUSTER_NAME, em que YOUR_PROJECT é o projeto do Google Cloud e CLUSTER_NAME é um nome exclusivo no projeto. Este campo é opcional.
- YOUR_PROJECT: o ID do projeto.
- GCP_REGION: a região do Google Cloud em que você quer armazenar os registros. Escolha uma região próxima à região da AWS. Para mais informações, consulte Locais globais: regiões e zonas. Por exemplo, us-central1.
- ENABLE_LOGGING: true ou false, se o Cloud Logging está ativado nos nós do plano de controle.
- ENABLE_MONITORING: true ou false, se o Cloud Monitoring está ativado nos nós do plano de controle.
- WORKLOAD_IDENTITY_BUCKET: o nome do bucket do Cloud Storage que contém suas informações de descoberta de identidade da carga de trabalho. Este campo é opcional.
Crie um ou mais AWSNodePools para o cluster. Abra um editor de texto e copie a seguinte definição de AWSCluster em um arquivo chamado custom-nodepools.yaml.
```
apiVersion: multicloud.cluster.gke.io/v1
kind: AWSNodePool
metadata:
  name: NODE_POOL_NAME
spec:
  clusterName: AWSCLUSTER_NAME
  version:  CLUSTER_VERSION # latest version is 1.25.5-gke.2100
  region: AWS_REGION
  subnetID: AWS_SUBNET_ID
  minNodeCount: MINIMUM_NODE_COUNT
  maxNodeCount: MAXIMUM_NODE_COUNT
  maxPodsPerNode: MAXIMUM_PODS_PER_NODE_COUNT
  instanceType: AWS_NODE_TYPE
  keyName: KMS_KEY_PAIR_NAME
  iamInstanceProfile: NODE_IAM_PROFILE
  proxySecretName: PROXY_SECRET_NAME
  rootVolume:
    sizeGiB: ROOT_VOLUME_SIZE
    volumeType: VOLUME_TYPE # Optional
    iops: IOPS # Optional
    kmsKeyARN: NODE_VOLUME_KEY # Optional 
```
Substitua:
- NODE_POOL_NAME: um nome exclusivo para o AWSNodePool.
- AWSCLUSTER_NAME: O nome do seu AWSCluster. Por exemplo, staging-cluster.
- CLUSTER_VERSION: uma versão compatível do GKE na AWS Kubernetes.
- AWS_REGION: a mesma região da AWS do AWSCluster.
- AWS_SUBNET_ID: uma sub-rede da AWS na mesma região do AWSCluster.
- MINIMUM_NODE_COUNT: o número mínimo de nós no pool. Consulte Como escalonar clusters de usuários para mais informações.
- MAXIMUM_NODE_COUNT: o número máximo de nós no pool.
- MAXIMUM_PODS_PER_NODE_COUNT: o número máximo de pods que o GKE na AWS pode alocar em um nó.
- AWS_NODE_TYPE: um tipo de instância do AWS EC2
- KMS_KEY_PAIR_NAME: O par de chaves KMS da AWS atribuído a cada worker do pool de nós.
- NODE_IAM_PROFILE: O nome do perfil da instância da AWS EC2 atribuída aos nós do pool.
- ROOT_VOLUME_SIZE: o tamanho, em gibibyte (GiB), dos volumes raiz do seu plano de controle.
- VOLUME_TYPE: o tipo de volume EBS da AWS do nó. Por exemplo, gp3.
- IOPS: a quantidade de operações de E/S provisionadas por segundo (IOPS, na sigla em inglês) para volumes. Válido apenas quando volumeType for gp3.
- NODE_VOLUME_KEY: o ARN da chave do KMS da AWS usado para criptografar o volume. Para mais informações, consulte Como usar uma CMK gerenciada pelo cliente para criptografar volumes.

Aplique os manifestos ao seu serviço de gerenciamento.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f custom-cluster.yaml
env HTTPS_PROXY=http://localhost:8118 \
  kubectl apply -f custom-nodepools.yaml

Criar um kubeconfig

Enquanto o cluster de usuários é iniciado, é possível criar um contexto kubeconfig para o novo cluster de usuários. Use o contexto para autenticar um usuário ou cluster de gerenciamento.

Use anthos-gke aws clusters get-credentials para gerar um kubeconfig para o cluster de usuários em ~/.kube/config.
```
env HTTPS_PROXY=http://localhost:8118 \
  anthos-gke aws clusters get-credentials CLUSTER_NAME
```
Substitua CLUSTER_NAME pelo nome do cluster. Por exemplo, cluster-0.
Use kubectl para se autenticar no novo cluster de usuário.
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl cluster-info
```
Se o cluster estiver pronto, a saída incluirá os URLs dos componentes do Kubernetes no cluster.

Como visualizar o status do cluster

O serviço de gerenciamento provisiona recursos da AWS quando você aplica um AWSCluster ou AWSNodePool.

No diretório anthos-aws, use anthos-gke para alternar o contexto para o serviço de gerenciamento.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Observação: anthos-gke usa as credenciais especificadas quando você executou aws configure.

Para listar os clusters, use kubectl get AWSClusters.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get AWSClusters

A saída inclui o nome, o estado, a idade, a versão e o endpoint de cada cluster.

Por exemplo, a saída a seguir inclui apenas um AWSCluster chamado cluster-0:

NAME        STATE          AGE     VERSION         ENDPOINT
cluster-0   Provisioning   2m41s   1.25.5-gke.2100   gke-xyz.elb.us-east-1.amazonaws.com

Ver os eventos do cluster

Para ver os Eventos do Kubernetes recentes no cluster de usuário, use o kubectl get events.

No diretório anthos-aws, use anthos-gke para alternar o contexto para o serviço de gerenciamento.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Observação: anthos-gke usa as credenciais especificadas quando você executou aws configure.

Execute kubectl get events.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl get events

A saída inclui informações, aviso e erros relacionados ao seu serviço de gerenciamento.

Como excluir um cluster de usuário

Para excluir um cluster de usuário, siga estas etapas:

No diretório anthos-aws, use anthos-gke para alternar o contexto para o serviço de gerenciamento.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Observação: anthos-gke usa as credenciais especificadas quando você executou aws configure.
Use kubectl delete para excluir o manifesto que contém seus clusters de usuário.
```
env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete -f CLUSTER_FILE
```
Substitua CLUSTER_FILE pelo nome do manifesto que contém os objetos do AWScluster e AWSNodePool. Por exemplo, cluster-0.yaml.

Como excluir todos os clusters de usuário

Para excluir todos os clusters de usuário, siga estas etapas:

No diretório anthos-aws, use anthos-gke para alternar o contexto para o serviço de gerenciamento.
```
cd anthos-aws
anthos-gke aws management get-credentials
```
Observação: anthos-gke usa as credenciais especificadas quando você executou aws configure.

Use kubectl delete para excluir o AWSNodePools e o AWSClusters do serviço de gerenciamento.

env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete AWSNodePool --all
env HTTPS_PROXY=http://localhost:8118 \
  kubectl delete AWSCluster --all

Para mais informações, consulte Como desinstalar o GKE na AWS.

A seguir

Configure seu provedor de identidade com o GKE Identity Service.
Inicie sua primeira carga de trabalho no GKE na AWS.
Crie uma implantação externa usando um balanceador de carga ou uma Entrada.
Leia as especificações das definições de recursos personalizados do AWSCluster e do AWSNodePool.