**Ajudar a melhorar esta página** 

Para contribuir com este guia de usuário, escolha o link **Editar esta página no GitHub**, disponível no painel direito de cada página.

# Criar um cluster do Modo Automático do EKS com a AWS CLI
<a name="automode-get-started-cli"></a>

Os clusters de modo automático do EKS automatizam as tarefas de rotina de gerenciamento de clusters para computação, armazenamento e rede. Por exemplo, os clusters do Modo Automático do EKS detectam automaticamente quando nós adicionais são necessários e provisionam novas instâncias do EC2 para atender às demandas de workloads.

Este tópico orienta você na criação de um novo cluster do Modo Automático do EKS usando a AWS CLI e, opcionalmente, na implantação de uma workload de exemplo.

## Pré-requisitos
<a name="_prerequisites"></a>
+ A versão mais recente da AWS Command Line Interface (AWS CLI) instalada e configurada no seu dispositivo. Para verificar sua versão atual, use `aws --version`. Para instalar a versão mais recente, consulte [Instalar](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e [Configuração rápida com aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html#cli-configure-quickstart-config), no Guia do usuário da AWS Command Line Interface.
  + Faça login na CLI com permissões suficientes do IAM para criar recursos da AWS, incluindo políticas do IAM, perfis do IAM e clusters do EKS.
+ A ferramenta de linha de comando do kubectl instalada no dispositivo. A AWS sugere que você use a mesma versão do kubectl que a versão do Kubernetes do cluster do EKS. Para instalar ou atualizar o kubectl, consulte [Configurar o `kubectl` e o `eksctl`](install-kubectl.md).

## Especificar sub-redes da VPC
<a name="_specify_vpc_subnets"></a>

O Modo Automático do Amazon EKS implanta nós em sub-redes da VPC. Ao criar um cluster do EKS, você deve especificar as sub-redes da VPC nas quais os nós serão implantados. Você pode usar as sub-redes da VPC padrão na conta da AWS ou criar uma VPC dedicada para workloads críticas.
+  A AWS sugere a criação de uma VPC dedicada para o cluster. Saiba como [Criar uma Amazon VPC para o cluster do Amazon EKS](creating-a-vpc.md).
+ O console do EKS ajuda na criação de uma nova VPC. Saiba como [Criar um cluster do Modo Automático do EKS com o Console de gerenciamento da AWS](automode-get-started-console.md).
+ Como alternativa, você pode usar a VPC padrão da conta da AWS. Use as instruções a seguir para encontrar os IDs de sub-rede.

### Para encontrar os IDs de sub-redes da VPC padrão
<a name="auto-find-subnet"></a>

 **Usar a AWS CLI:** 

1. Execute o comando a seguir para listar a VPC padrão e suas sub-redes:

   ```
   aws ec2 describe-subnets --filters "Name=vpc-id,Values=$(aws ec2 describe-vpcs --query 'Vpcs[?IsDefault==`true`].VpcId' --output text)" --query 'Subnets[*].{ID:SubnetId,AZ:AvailabilityZone}' --output table
   ```

1. Salve a saída e anote os **IDs das sub-redes**.

   Exemplo de resultado:

   ```
   ----------------------------------------
   |             DescribeSubnets          |
   ----------------------------------------
   |   SubnetId        |   AvailabilityZone  |
   |--------------------|---------------------|
   |   subnet-012345678 |   us-west-2a        |
   |   subnet-234567890 |   us-west-2b        |
   |   subnet-345678901 |   us-west-2c        |
   ----------------------------------------
   ```

## Perfis do IAM de clusters do Modo Automático do EKS
<a name="auto-mode-create-roles"></a>

### Perfil do IAM do cluster
<a name="auto-roles-cluster-iam-role"></a>

O Modo Automático do EKS exige um perfil do IAM do cluster para realizar ações na conta da AWS, como provisionar novas instâncias do EC2. Você deve criar esse perfil para conceder ao EKS as permissões necessárias. A AWS recomenda anexar as seguintes políticas gerenciadas pela AWS ao perfil do IAM do cluster:
+  [AmazonEKSComputePolicy](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonEKSComputePolicy) 
+  [AmazonEKSBlockStoragePolicy](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonEKSBlockStoragePolicy) 
+  [AmazonEKSLoadBalancingPolicy](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonEKSLoadBalancingPolicy) 
+  [AmazonEKSNetworkingPolicy](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonEKSNetworkingPolicy) 
+  [AmazonEKSClusterPolicy](security-iam-awsmanpol.md#security-iam-awsmanpol-amazoneksclusterpolicy) 

### Perfil do IAM do nó
<a name="auto-roles-node-iam-role"></a>

Ao criar um cluster do Modo Automático do EKS, você especifica um perfil do IAM do nó. Quando o Modo Automático do EKS cria nós para processar workloads pendentes, cada novo nó de instância do EC2 recebe o perfil do IAM do nó. Esse perfil permite que o nó se comunique com o EKS, mas geralmente não é acessado pelas workloads em execução no nó.

Se você quiser conceder permissões para workloads em execução em um nó, use a Identidade de Pods do EKS. Para obter mais informações, consulte [Saiba como a Identidade de Pods do EKS concede aos pods acesso aos serviços da AWS](pod-identities.md).

Você deve criar esse perfil e anexar a seguinte política gerenciada pela AWS:
+  [AmazonEKSWorkerNodeMinimalPolicy](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonEKSWorkerNodeMinimalPolicy) 
+  [AmazonEC2ContainerRegistryPullOnly](https://docs.aws.amazon.com/AmazonECR/latest/userguide/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonEC2ContainerRegistryPullOnly) 

O Modo Automático do EKS também requer um perfil vinculado ao serviço, que é criado e configurado automaticamente pela AWS. Para obter mais informações, consulte [AWSServiceRoleForAmazonEKS](using-service-linked-roles-eks.md).

## Criar um perfil do IAM do cluster do Modo Automático do EKS
<a name="_create_an_eks_auto_mode_cluster_iam_role"></a>

### Etapa 1: criar a política de confiança
<a name="_step_1_create_the_trust_policy"></a>

Crie uma política de confiança para permitir que o serviço do Amazon EKS assuma o perfil. Salve a política como `trust-policy.json`:

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow", 
      "Principal": {
        "Service": "eks.amazonaws.com"
      },
      "Action": [
        "sts:AssumeRole",
        "sts:TagSession"
      ]
    }
  ]
}
```

### Etapa 2: criar o perfil do IAM
<a name="_step_2_create_the_iam_role"></a>

Use a política de confiança para criar o perfil do IAM do cluster:

```
aws iam create-role \
    --role-name AmazonEKSAutoClusterRole \
    --assume-role-policy-document file://trust-policy.json
```

### Etapa 3: registre o ARN do perfil
<a name="_step_3_note_the_role_arn"></a>

Recupere e salve o ARN do novo perfil para uso nas etapas subsequentes:

```
aws iam get-role --role-name AmazonEKSAutoClusterRole --query "Role.Arn" --output text
```

### Etapa 4: anexar as políticas necessárias
<a name="_step_4_attach_required_policies"></a>

Anexe as seguintes políticas gerenciadas pela AWS ao perfil do IAM do cluster para conceder as permissões necessárias:

 **AmazonEKSClusterPolicy**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoClusterRole \
    --policy-arn arn:aws:iam::aws:policy/AmazonEKSClusterPolicy
```

 **AmazonEKSComputePolicy**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoClusterRole \
    --policy-arn arn:aws:iam::aws:policy/AmazonEKSComputePolicy
```

 **AmazonEKSBlockStoragePolicy**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoClusterRole \
    --policy-arn arn:aws:iam::aws:policy/AmazonEKSBlockStoragePolicy
```

 **AmazonEKSLoadBalancingPolicy**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoClusterRole \
    --policy-arn arn:aws:iam::aws:policy/AmazonEKSLoadBalancingPolicy
```

 **AmazonEKSNetworkingPolicy**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoClusterRole \
    --policy-arn arn:aws:iam::aws:policy/AmazonEKSNetworkingPolicy
```

## Criar um perfil do IAM do nó do Modo Automático do EKS
<a name="_create_an_eks_auto_mode_node_iam_role"></a>

### Etapa 1: criar a política de confiança
<a name="_step_1_create_the_trust_policy_2"></a>

Crie uma política de confiança para permitir que o serviço do Amazon EKS assuma o perfil. Salve a política como `node-trust-policy.json`:

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "ec2.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

#### Etapa 2: criar o perfil do IAM do nó
<a name="_step_2_create_the_node_iam_role"></a>

Use o arquivo **node-trust-policy.json** da etapa anterior para definir quais entidades podem assumir o perfil. Execute o seguinte comando para criar o perfil do IAM do nó:

```
aws iam create-role \
    --role-name AmazonEKSAutoNodeRole \
    --assume-role-policy-document file://node-trust-policy.json
```

#### Etapa 3: registre o ARN do perfil
<a name="_step_3_note_the_role_arn_2"></a>

Depois de criar o perfil, recupere e salve o ARN do perfil do IAM do nó. Você precisará desse ARN nas etapas subsequentes. Use o seguinte comando para obter o ARN:

```
aws iam get-role --role-name AmazonEKSAutoNodeRole --query "Role.Arn" --output text
```

#### Etapa 4: anexar as políticas necessárias
<a name="_step_4_attach_required_policies_2"></a>

Anexe as seguintes políticas gerenciadas pela AWS ao perfil do IAM do nó para fornecer as permissões necessárias:

 **AmazonEKSWorkerNodeMinimalPolicy**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoNodeRole \
    --policy-arn arn:aws:iam::aws:policy/AmazonEKSWorkerNodeMinimalPolicy
```

 **AmazonEC2ContainerRegistryPullOnly**:

```
aws iam attach-role-policy \
    --role-name AmazonEKSAutoNodeRole \
    --policy-arn arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryPullOnly
```

## Criar um cluster do Modo Automático do EKS
<a name="_create_an_eks_auto_mode_cluster"></a>

### Visão geral
<a name="_overview"></a>

Para criar um cluster de Modo Automático do EKS usando a AWS CLI, você precisará dos seguintes parâmetros:
+  `cluster-name`: o nome do cluster.
+  `k8s-version`: a versão do Kubernetes (por exemplo, 1.31).
+  `subnet-ids`: IDs de sub-rede identificados nas etapas anteriores.
+  `cluster-role-arn`: ARN do perfil do IAM do cluster.
+  `node-role-arn`: ARN do perfil do IAM do nó.

#### Configurações padrão do cluster
<a name="_default_cluster_configurations"></a>

Analise estes valores e recursos padrão antes de criar o cluster:
+  `nodePools`: o Modo Automático do EKS inclui grupos de nós de uso geral e padrão do sistema. Saiba mais sobre [Grupos de nós](create-node-pool.md).

 **Observação:** os grupos de nós no Modo Automático do EKS diferem dos grupos dos nós gerenciados pelo Amazon EKS, mas podem coexistir no mesmo cluster.
+  `computeConfig.enabled`: automatiza tarefas computacionais de rotina, como criar e excluir instâncias do EC2.
+  `kubernetesNetworkConfig.elasticLoadBalancing.enabled`: automatiza as tarefas de balanceamento de carga, incluindo a criação e exclusão de Elastic Load Balancers.
+  `storageConfig.blockStorage.enabled`: automatiza tarefas de armazenamento, como criar e excluir volumes do Amazon EBS.
+  `accessConfig.authenticationMode`: requer entradas de acesso do EKS. Saiba mais sobre os [modos de autenticação do EKS](grant-k8s-access.md).

#### Executar o comando
<a name="_run_the_command"></a>

Use o seguinte comando para criar o cluster:

```
aws eks create-cluster \
  --region ${AWS_REGION} \
  --cli-input-json \
  "{
      \"name\": \"${CLUSTER_NAME}\",
      \"version\": \"${K8S_VERSION}\",
      \"roleArn\": \"${CLUSTER_ROLE_ARN}\",
      \"resourcesVpcConfig\": {
        \"subnetIds\": ${SUBNETS_JSON},
        \"endpointPublicAccess\": true,
        \"endpointPrivateAccess\": true
      },
      \"computeConfig\": {
        \"enabled\": true,
        \"nodeRoleArn\":\"${NODE_ROLE_ARN}\",
        \"nodePools\": [\"general-purpose\", \"system\"]
      },
      \"kubernetesNetworkConfig\": {
        \"elasticLoadBalancing\": {
          \"enabled\": true
        }
      },
      \"storageConfig\": {
        \"blockStorage\": {
          \"enabled\": true
        }
      },
      \"accessConfig\": {
        \"authenticationMode\": \"API\"
      }
    }"
```

### Verificar o status do cluster
<a name="_check_cluster_status"></a>

#### Etapa 1: verificar a criação do cluster
<a name="_step_1_verify_cluster_creation"></a>

Execute o comando a seguir para verificar o status do cluster. A criação do cluster normalmente leva cerca de 15 minutos.

```
aws eks describe-cluster --name "${CLUSTER_NAME}" --output json
```

#### Etapa 2: atualizar o kubeconfig
<a name="_step_2_update_kubeconfig"></a>

Quando o cluster estiver pronto, atualize o arquivo kubeconfig local para permitir que o `kubectl` se comunique com o cluster. Esta configuração usa a AWS CLI para autenticação.

```
aws eks update-kubeconfig --name "${CLUSTER_NAME}"
```

#### Etapa 3: verificar grupos de Node
<a name="_step_3_verify_node_pools"></a>

Listar os grupos de nós no cluster com o comando a seguir:

```
kubectl get nodepools
```

## Próximas etapas
<a name="_next_steps"></a>
+ Saiba como [implantar uma workload de exemplo](automode-workload.md) no novo cluster do Modo Automático do EKS.