

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

# Implantar um cluster do Amazon EKS em AWS Outposts
<a name="eks-outposts-local-cluster-create"></a>

Este tópico fornece uma visão geral do que deve ser considerado ao executar um cluster local em um Outpost. O tópico também fornece instruções sobre como implantar um cluster local em um Outpost.

**Importante**  
Essas considerações não são replicadas na documentação relacionada do Amazon EKS. Se outros tópicos da documentação do Amazon EKS entrarem em conflito com as considerações aqui apresentadas, siga estas considerações.
Essas considerações estão sujeitas a alterações, que podem ocorrer com frequência. Portanto, recomendamos que você revise este tópico periodicamente.
Muitas das considerações são diferentes das considerações para a criação de um cluster no AWS Cloud.
+ Os clusters locais somente são compatíveis com racks do Outpost. Um único cluster local pode ser executado em vários racks físicos do Outpost que incluem um único Outpost lógico. Um único cluster local não pode ser executado em vários Outposts lógicos. Cada Outpost lógico tem um único ARN de Outpost.
+ Clusters locais executam e gerenciam o ambiente de gerenciamento do Kubernetes na sua conta no Outpost. Você não pode executar workloads nas instâncias do ambiente de gerenciamento do Kubernetes nem modificar os componentes dele. Esses nós são gerenciados pelo serviço do Amazon EKS. As alterações no ambiente de gerenciamento do Kubernetes não persistem por meio de ações automáticas de gerenciamento do Amazon EKS, como aplicação de patches.
+ Os clusters locais são compatíveis com complementos autogerenciados e grupos de nós autogerenciados do Amazon Linux. O plug-in [Amazon VPC CNI para Kubernetes](managing-vpc-cni.md), o [kube-proxy](managing-kube-proxy.md) e os complementos [CoreDNS](managing-coredns.md) são instalados automaticamente nos clusters locais.
+ Os clusters locais exigem o uso do Amazon EBS no Outposts. O Outpost deve ter o Amazon EBS disponível para o armazenamento do ambiente de gerenciamento do Kubernetes. O Outposts somente é compatível com volumes `gp2` do Amazon EBS.
+ Os `PersistentVolumes` do Kubernetes baseados no Amazon EBS são compatíveis com o uso do driver CSI do Amazon EBS.
+ As instâncias do ambiente de gerenciamento dos clusters locais são configuradas em uma [topologia empilhada altamente disponível](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/ha-topology/). Duas das três instâncias do ambiente de gerenciamento devem estar sempre íntegras para manter o quórum. Se o quórum for perdido, entre em contato com o suporte da AWS, pois algumas ações do lado do serviço serão necessárias para habilitar as novas instâncias gerenciadas.

 **Pré-requisitos** 
+ Familiaridade com as [opções de implementação do Outposts](eks-outposts.md#outposts-overview-comparing-deployment-options), [Selecione tipos de instância e grupos de posicionamento para clusters do Amazon EKS no AWS Outposts com base em considerações de capacidade](eks-outposts-capacity-considerations.md) e [requisitos e considerações de VPC](eks-outposts-vpc-subnet-requirements.md).
+ Um Outpost existente. Para obter mais informações, consulte [O que é AWS Outposts](https://docs.aws.amazon.com/outposts/latest/userguide/what-is-outposts.html).
+ A ferramenta da linha de comando `kubectl` está instalada no seu computador ou no AWS CloudShell. A versão pode ser a mesma ou até uma versão secundária anterior ou posterior à versão do Kubernetes do seu cluster. Por exemplo, se a versão do cluster for a `1.29`, será possível usar o `kubectl` versão `1.28`, `1.29` ou `1.30` com ele. Para instalar ou atualizar o `kubectl`, consulte [Configurar o `kubectl` e o `eksctl`](install-kubectl.md).
+ Versão `2.12.3` ou posterior ou versão `1.27.160` ou posterior da AWS Command Line Interface (AWS CLI) instalada e configurada no seu dispositivo ou no AWS CloudShell. Para verificar sua versão atual, use `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Os gerenciadores de pacotes, como `yum`, `apt-get` ou Homebrew para macOS, geralmente estão várias versões atrás da versão mais recente da AWS CLI. Para instalar a versão mais recente, consulte [Installing](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) e [Quick configuration with aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config), no *Guia do usuário da AWS Command Line Interface*. A versão da AWS CLI instalada no AWS CloudShell também pode estar várias versões atrás da versão mais recente. Para atualizá-lo, consulte [Instalar a AWS CLI no seu diretório pessoal](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software), no * Guia do usuário do AWS CloudShell*.
+ Uma entidade principal do IAM (usuário ou perfil) com permissões para `create` e `describe` um cluster do Amazon EKS. Para obter mais informações, consulte [Criar um cluster local do Kubernetes em um Outpost](security-iam-id-based-policy-examples.md#policy-create-local-cluster) e [Listar ou descrever todos os clusters](security-iam-id-based-policy-examples.md#policy-example2).

Quando um cluster local do Amazon EKS é criado, a [entidade principal do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal) que cria o cluster é adicionada permanentemente. A entidade principal é adicionada especificamente à tabela de autorização RBAC do Kubernetes como administradora. Esta entidade tem permissões `system:masters`. A identidade desta entidade não fica visível na configuração do seu cluster. Por isso, é importante observar a entidade que criou o cluster e garantir que ela nunca tenha sido excluída. Inicialmente, somente a entidade principal que criou o servidor poderá fazer chamadas para o servidor de API do Kubernetes usando o `kubectl`. Se usar o console para criar o cluster, você deverá se certificar de que as mesmas credenciais do IAM estejam na cadeia de credenciais do AWS SDK quando executar os comandos `kubectl` no cluster. Depois de criar o cluster, você poderá conceder acesso a ele para outras entidades do IAM.

## Criar um cluster local do Amazon EKS
<a name="_create_an_amazon_eks_local_cluster"></a>

Você pode criar um cluster local com as seguintes ferramentas descritas nesta página:
+  [`eksctl`](#eksctl_create_cluster_outpost) 
+  [Console de gerenciamento da AWS](#console_create_cluster_outpost) 

Além disso, é possível usar a [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/eks/create-cluster.html), a [API do Amazon EKS](https://docs.aws.amazon.com/eks/latest/APIReference/API_CreateCluster.html), os [AWS SDKs](https://aws.amazon.com/developer/tools/), o [AWS CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-eks-cluster-outpostconfig.html) ou o [Terraform](https://registry.terraform.io/modules/terraform-aws-modules/eks/aws/latest) para a criação de clusters no Outposts.

### `eksctl`
<a name="eksctl_create_cluster_outpost"></a>

 **Para criar um cluster local com `eksctl` ** 

1. Instale a versão `0.215.0` ou posterior da ferramenta de linha de comando `eksctl` em seu dispositivo ou AWS CloudShell. Para instalar ou atualizar o `eksctl`, consulte [Instalação](https://eksctl.io/installation) na documentação do `eksctl`.

1. Copie o conteúdo a seguir no seu dispositivo. Substitua os valores a seguir e execute o comando modificado para criar o arquivo `outpost-control-plane.yaml`:
   + Substitua *region-code* pela [região AWS suportada](eks-outposts-local-cluster-overview.md#outposts-control-plane-supported-regions) na qual você deseja criar o cluster.
   + Substitua *my-cluster* por um nome para seu cluster. O nome só pode conter caracteres alfanuméricos (sensíveis a maiúsculas e minúsculas) e hifens. Ele deve começar com um caractere alfanumérico e não pode ter mais de 100 caracteres. O nome deve ser exclusivo na região da AWS e na conta da AWS em que você está criando o cluster. O nome deve ser exclusivo na região da AWS e na conta da AWS em que você está criando o cluster.
   + Substitua *vpc-ExampleID1* e *subnet-ExampleID1* pelos IDs da sua VPC e da sub-rede existentes. A VPC e a sub-rede devem atender aos requisitos em [Criar uma VPC e sub-redes para clusters do Amazon EKS no AWS Outposts](eks-outposts-vpc-subnet-requirements.md).
   + Substitua *uniqueid* pelo ID do seu Outpost.
   + Substitua *m5.large* por um tipo de instância disponível no seu Outpost. Antes de escolher um tipo de instância, consulte [Selecione tipos de instância e grupos de posicionamento para clusters do Amazon EKS em AWS Outposts com base em considerações de capacidade](eks-outposts-capacity-considerations.md). Três instâncias do ambiente de gerenciamento são implantadas. Não é possível alterar esse número.

     ```
     cat >outpost-control-plane.yaml <<EOF
     apiVersion: eksctl.io/v1alpha5
     kind: ClusterConfig
     
     metadata:
       name: my-cluster
       region: region-code
       version: "1.35"
     
     vpc:
       clusterEndpoints:
         privateAccess: true
       id: "vpc-vpc-ExampleID1"
       subnets:
         private:
           outpost-subnet-1:
             id: "subnet-subnet-ExampleID1"
     
     outpost:
       controlPlaneOutpostARN: arn:aws:outposts:region-code:111122223333:outpost/op-uniqueid
       controlPlaneInstanceType: m5.large
     EOF
     ```

     Para obter uma lista completa de todas as opções e padrões disponíveis, consulte [AWS Outposts Support](https://eksctl.io/usage/outposts/) e [Config file schema](https://eksctl.io/usage/schema/) na documentação `eksctl`.

1. Crie o cluster usando o arquivo de configuração que você criou na etapa anterior. O `eksctl` cria uma VPC e uma sub-rede no seu Outpost para implantar o cluster.

   ```
   eksctl create cluster -f outpost-control-plane.yaml
   ```

   O provisionamento de cluster leva alguns minutos. Durante a criação do cluster, várias linhas de saída são exibidas. A última linha do resultado é semelhante ao exemplo de linha a seguir.

   ```
   [✓]  EKS cluster "my-cluster" in "region-code" region is ready
   ```
**dica**  
Para ver a maioria das opções que podem ser especificadas ao criar um cluster com `eksctl`, use o comando `eksctl create cluster --help`. Para ver todas as opções disponíveis, é possível utilizar um arquivo `config`. Para obter mais informações, consulte [Uso dos arquivos de configuração](https://eksctl.io/usage/creating-and-managing-clusters/#using-config-files) e o [esquema de arquivo de configuração](https://eksctl.io/usage/schema/) na documentação do `eksctl`. Você pode encontrar [exemplos de arquivos de configuração](https://github.com/weaveworks/eksctl/tree/master/examples) no GitHub.

   O comando `eksctl` criou automaticamente uma [entrada de acesso](access-entries.md) para a entidade principal do IAM (usuário ou perfil) que criou o cluster, e concedeu à entidade principal do IAM permissões de administrador para objetos do Kubernetes no cluster. Se não quiser que o criador do cluster tenha acesso de administrador aos objetos do Kubernetes no cluster, adicione o seguinte texto ao arquivo de configuração anterior: `bootstrapClusterCreatorAdminPermissions: false` (no mesmo nível que `metadata`, `vpc` e `outpost`). Caso tenha adicionado a opção, então, depois da criação do cluster, você precisará criar uma entrada de acesso para pelo menos uma entidade principal do IAM, ou nenhuma entidade principal do IAM terá acesso aos objetos do Kubernetes no cluster.

### Console de gerenciamento da AWS
<a name="console_create_cluster_outpost"></a>

 **Para criar o cluster com a Console de gerenciamento da AWS ** 

1. Você precisa de uma VPC e uma sub-rede existentes que atendam aos requisitos do Amazon EKS. Para obter mais informações, consulte [Criar um VPC e sub-redes para clusters do Amazon EKS em AWS Outposts](eks-outposts-vpc-subnet-requirements.md).

1. Se você já tiver um perfil do IAM do cluster local ou se for criar seu cluster com `eksctl`, poderá ignorar essa etapa. Por padrão, `eksctl` cria um perfil para você.

   1. Execute o comando a seguir para criar um arquivo JSON de política de confiança do IAM:

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

   1. Crie o perfil do IAM do cluster do Amazon EKS. Para criar um perfil do IAM, a [entidade principal do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal) que estiver criando o perfil deverá ser atribuída à seguinte ação `iam:CreateRole` (permissão):

      ```
      aws iam create-role --role-name myAmazonEKSLocalClusterRole --assume-role-policy-document file://"eks-local-cluster-role-trust-policy.json"
      ```

   1. Anexe a política gerenciada do Amazon EKS denominada [AmazonEKSLocalOutpostClusterPolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEKSLocalOutpostClusterPolicy.html) ao perfil. Para anexar uma política do IAM a uma [entidade principal do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html#iam-term-principal) a entidade principal do IAM que está anexando a política deve receber uma das seguintes ações do IAM (permissões): `iam:AttachUserPolicy` ou `iam:AttachRolePolicy`.

      ```
      aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonEKSLocalOutpostClusterPolicy --role-name myAmazonEKSLocalClusterRole
      ```

1. Abra o [console do Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).

1. Na parte superior da tela do console, certifique-se de ter selecionado uma [região compatível com AWS](eks-outposts-local-cluster-overview.md#outposts-control-plane-supported-regions).

1. Escolha **Add cluster** (Adicionar cluster) e, em seguida, **Create** (Criar).

1. Na página **Configure cluster** (Configurar cluster), insira ou selecione valores para os seguintes campos:
   +  **Localização do ambiente de gerenciamento do Kubernetes**: escolha AWS Outposts.
   +  **Outpost ID** (ID do Outpost): escolha o ID do Outpost no qual você deseja criar seu ambiente de gerenciamento.
   +  Em **Instance type** (Tipo de instância): selecione um tipo de instância. Somente os tipos de instância disponíveis no seu Outpost são exibidos. Na lista suspensa, cada tipo de instância descreve para quantos nós o tipo de instância é recomendado. Antes de escolher um tipo de instância, consulte [Selecione tipos de instância e grupos de posicionamento para clusters do Amazon EKS em AWS Outposts com base em considerações de capacidade](eks-outposts-capacity-considerations.md). Todas as réplicas são implantadas com o uso do mesmo tipo de instância. Você não poderá alterar o tipo de instância depois que seu cluster for criado. Três instâncias do ambiente de gerenciamento são implantadas. Não é possível alterar esse número.
   +  **Name** (Nome): um nome exclusivo para o cluster. Ele deve ser exclusivo na sua conta da AWS. O nome só pode conter caracteres alfanuméricos (sensíveis a maiúsculas e minúsculas) e hifens. Ele deve começar com um caractere alfanumérico e não pode ter mais de 100 caracteres. O nome deve ser exclusivo na região da AWS e na conta da AWS em que você está criando o cluster. O nome deve ser exclusivo na região da AWS e na conta da AWS em que você está criando o cluster.
   +  **Versão do Kubernetes**: escolha a versão do Kubernetes que você deseja usar para o cluster. A menos que precise usar uma versão anterior, recomendamos que você selecione a versão mais recente.
   +  **Perfil de serviço do cluster**: escolha o perfil do IAM do cluster do Amazon EKS criado em uma etapa anterior para permitir que o ambiente de gerenciamento do Kubernetes gerencie os recursos da AWS.
   +  **Acesso de administrador do cluster do Kubernetes**: se quiser que a entidade principal do IAM (perfil ou usuário) que está criando o cluster tenha acesso de administrador aos objetos Kubernetes no cluster, aceite o padrão (permitir). O Amazon EKS cria uma entrada de acesso para a entidade principal do IAM e concede permissões de administrador do cluster à entrada de acesso. Para obter mais informações sobre as entradas de acesso, consulte [Conceder aos usuários do IAM acesso ao Kubernetes com entradas de acesso ao EKS](access-entries.md).

     Se você quiser que uma entidade principal do IAM diferente daquela que está criando o cluster tenha acesso de administrador aos objetos do Kubernetes do cluster, escolha a opção de não permitir. Após a criação do cluster, qualquer entidade principal do IAM que tenha permissões do IAM para criar entradas de acesso poderá adicionar uma entrada de acesso para qualquer entidade principal do IAM que precise acessar os objetos do Kubernetes do cluster. Para obter mais informações sobre as permissões necessárias do IAM, consulte [Ações definidas pelo Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonelastickubernetesservice.html#amazonelastickubernetesservice-actions-as-permissions) na Referência de autorização de serviço. Se você escolher a opção de não permitir e não criar nenhuma entrada de acesso, nenhuma entidade principal do IAM terá acesso aos objetos do Kubernetes no cluster.
   +  **Tags** (Etiquetas) – (opcional) adicione etiquetas ao cluster. Para obter mais informações, consulte [Organizar recursos do Amazon EKS com tags](eks-using-tags.md). Após terminar com essa página, escolha **Próximo**.

1. Na página **Specify networking** (Especificar redes), selecione valores para os seguintes campos:
   +  **VPC**: escolha uma VPC existente. A VPC deve ter uma quantidade suficiente de endereços IP disponíveis para o cluster, todos os nós e outros recursos Kubernetes que você deseja criar. Sua VPC deve atender aos requisitos em [Requisitos e considerações da VPC](eks-outposts-vpc-subnet-requirements.md#outposts-vpc-requirements).
   +  **Subnets** (Sub-redes): por padrão, as sub-redes disponíveis na VPC especificada no campo anterior são pré-selecionadas. As sub-redes que você escolher devem atender aos requisitos em [Requisitos e considerações da sub-rede](eks-outposts-vpc-subnet-requirements.md#outposts-subnet-requirements).
   +  **Security groups** (Grupos de segurança) (Opcional): especifique um ou mais grupos de segurança que você deseja que o Amazon EKS associe às interfaces de rede que ele cria. O Amazon EKS cria automaticamente um grupo de segurança que permite a comunicação entre o cluster e a VPC. O Amazon EKS associa esse grupo de segurança, e qualquer um que você escolher, às interfaces de rede que ele cria. Para saber mais sobre o grupo de segurança de cluster criado pelo Amazon EKS, consulte [Exibir os requisitos para grupos de segurança do Amazon EKS em clusters](sec-group-reqs.md). É possível modificar as regras no grupo de segurança do cluster criado pelo Amazon EKS. Se optar por adicionar seus próprios grupos de segurança, você não poderá alterar os escolhidos após a criação desse cluster. Para que os hosts on-premises se comuniquem com o endpoint do cluster, você deve permitir tráfego de entrada do grupo de segurança do cluster. Para clusters que não têm uma conexão de internet de entrada e saída (também conhecidos como clusters privados), você deve fazer o seguinte:
     + Adicione o grupo de segurança associado aos endpoints da VPC necessários. Para obter mais informações sobre os endpoints necessários, consulte [Usar VPC endpoints da interface do](eks-outposts-vpc-subnet-requirements.md#vpc-subnet-requirements-vpc-endpoints) em [Acesso da sub-rede a serviços da AWS](eks-outposts-vpc-subnet-requirements.md#subnet-access-to-services).
     + Modifique o grupo de segurança que o Amazon EKS criou para permitir tráfego do grupo de segurança associado aos endpoints da VPC. Após terminar com essa página, escolha **Próximo**.

1. Na página **Configurar observabilidade**, é possível escolher opcionalmente quais opções de **Métricas** e **Log do ambiente de gerenciamento** você deseja ativar. Por padrão, o cada tipo de log está desativado.
   + Para obter mais informações sobre a opção de métricas do Prometheus, consulte [Etapa 1: ativar as métricas do Prometheus](prometheus.md#turn-on-prometheus-metrics).
   + Para obter mais informações sobre as opções do **Log do ambiente de gerenciamento**, consulte [Enviar logs do ambiente de gerenciamento para o CloudWatch Logs](control-plane-logs.md). Após terminar com essa página, escolha **Próximo**.

1. Na página **Review and create (Revisar e criar)**, revise as informações que você inseriu ou selecionou nas páginas anteriores. Se precisar fazer alterações, escolha **Edit** (Editar). Quando estiver satisfeito, escolha **Criar**. O campo **Status** mostra o campo **CREATING** (Criando) enquanto o cluster é provisionado.

   O provisionamento de cluster leva alguns minutos.

## Visualizar seu cluster local do Amazon EKS
<a name="_view_your_amazon_eks_local_cluster"></a>

1. Depois que o cluster for criado, você poderá visualizar as instâncias do ambiente de gerenciamento do Amazon EC2 que foram criadas.

   ```
   aws ec2 describe-instances --query 'Reservations[*].Instances[*].{Name:Tags[?Key==`Name`]|[0].Value}' | grep my-cluster-control-plane
   ```

   Veja um exemplo de saída abaixo.

   ```
   "Name": "my-cluster-control-plane-id1"
   "Name": "my-cluster-control-plane-id2"
   "Name": "my-cluster-control-plane-id3"
   ```

   Cada instância recebeu taints com o `node-role.eks-local.amazonaws.com/control-plane` para que nenhuma workload seja programada nas instâncias do ambiente de gerenciamento. Para obter mais informações sobre taints, consulte [Taints e Tolerâncias](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/) na documentação do Kubernetes. O Amazon EKS monitora continuamente o estado dos clusters locais. Executamos ações automáticas de gerenciamento, como patches de segurança e reparo de instâncias não íntegras. Quando os clusters locais são desconectados da nuvem, executamos ações para garantir que o cluster seja reparado para um estado íntegro após a reconexão.

1. Se você criou seu cluster usando `eksctl`, pode ignorar esta etapa. O `eksctl` completa esta etapa para você. Habilite o `kubectl` para se comunicar com o cluster adicionando um novo contexto ao arquivo `kubectl` `config`. Para obter instruções sobre como criar e atualizar o arquivo, consulte [Conecte o kubectl a um cluster de EKS criando um arquivo kubeconfig](create-kubeconfig.md).

   ```
   aws eks update-kubeconfig --region region-code --name my-cluster
   ```

   Veja abaixo um exemplo de saída.

   ```
   Added new context arn:aws:eks:region-code:111122223333:cluster/my-cluster to /home/username/.kube/config
   ```

1. Para se conectar ao servidor de API do Kubernetes do cluster local, você deve ter acesso ao gateway local da sub-rede ou conectar-se de dentro da VPC. Para obter mais informações sobre como conectar um rack de Outpost à sua rede on-premises, consulte [Como funcionam gateways locais para racks](https://docs.aws.amazon.com/outposts/latest/userguide/how-racks-work.html) no Guia do usuário do AWS Outposts. Se você usar roteamento direto da VPC e a sub-rede do Outpost tiver uma rota para o gateway local, os endereços IP privados das instâncias do ambiente de gerenciamento do Kubernetes serão transmitidos automaticamente pela rede local. O endpoint do servidor de API do Kubernetes do cluster local está hospedado no Amazon Route 53 (Route 53). O endpoint do serviço de API pode ser resolvido por servidores DNS públicos para os endereços IP privados dos servidores de API do Kubernetes.

   As instâncias do ambiente de gerenciamento do Kubernetes dos clusters locais são configuradas com interfaces de rede elásticas estáticas com endereços IP privados fixos que não mudam durante o ciclo de vida do cluster. As máquinas que interagem com o servidor de API do Kubernetes podem não ter conectividade com o Route 53 durante as desconexões da rede. Se for esse o caso, recomendamos configurar `/etc/hosts` com os endereços IP privados estáticos para operações contínuas. Também recomendamos configurar servidores DNS locais e conectá-los ao Outpost. Para obter mais informações, consulte a [documentação doAWS Outposts](https://docs.aws.amazon.com/outposts/latest/userguide/how-outposts-works.html#dns). Execute o comando a seguir para confirmar que a comunicação foi estabelecida com o cluster.

   ```
   kubectl get svc
   ```

   Veja abaixo um exemplo de saída.

   ```
   NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
   kubernetes   ClusterIP   10.100.0.1   <none>        443/TCP   28h
   ```

1. (Opcional) Teste a autenticação em seu cluster local quando ele estiver em um estado desconectado do AWS Cloud. Para instruções, consulte [Prepare clusters locais do Amazon EKS em AWS Outposts para desconexões de rede](eks-outposts-network-disconnects.md).

### Recursos internos
<a name="outposts-control-plan-internal-resources"></a>

O Amazon EKS cria os seguintes recursos no seu cluster. Os recursos são para uso interno do Amazon EKS. Para o funcionamento adequado do cluster, não edite nem modifique esses recursos.
+ Os seguintes [pods de espelho](https://kubernetes.io/docs/reference/glossary/?all=true#term-mirror-pod):
  +  `aws-iam-authenticator-node-hostname ` 
  +  `eks-certificates-controller-node-hostname ` 
  +  `etcd-node-hostname ` 
  +  `kube-apiserver-node-hostname ` 
  +  `kube-controller-manager-node-hostname ` 
  +  `kube-scheduler-node-hostname ` 
+ Os seguintes complementos autogerenciados:
  +  `kube-system/coredns` 
  +  `kube-system/` `kube-proxy` (só será criado quando você adicionar seu primeiro nó)
  +  `kube-system/aws-node` (só será criado quando você adicionar seu primeiro nó). Clusters locais usam o plug-in CNI da Amazon VPC para o plug-in do Kubernetes de redes de clusters. Não altere a configuração das instâncias do ambiente de gerenciamento (pods denominados `aws-node-controlplane-*`). Há variáveis de configuração que você pode usar para alterar o valor padrão para quando o plug-in criar novas interfaces de rede. Para obter mais informações, consulte a [documentação](https://github.com/aws/amazon-vpc-cni-k8s/blob/master/README.md) sobre o GitHub.
+ Os seguintes serviços:
  +  `default/kubernetes` 
  +  `kube-system/kube-dns` 
+ Um `PodSecurityPolicy` denominado `eks.system` 
+ Um `ClusterRole` denominado `eks:system:podsecuritypolicy` 
+ Um `ClusterRoleBinding` denominado `eks:system` 
+ Além do [grupo de segurança do cluster](sec-group-reqs.md), o Amazon EKS cria um grupo de segurança em sua conta AWS chamado `eks-local-internal-do-not-use-or-edit-cluster-name-uniqueid `. Esse grupo de segurança permite que o tráfego flua livremente entre os componentes do Kubernetes em execução nas instâncias do ambiente de gerenciamento.

Próximas etapas recomendadas:
+  [Conceda à entidade principal do IAM que criou o cluster as permissões necessárias para visualizar os recursos do Kubernetes no Console de gerenciamento da AWS](view-kubernetes-resources.md#view-kubernetes-resources-permissions) 
+  [Conceda acesso para entidades do IAM ao cluster](grant-k8s-access.md). Se quiser que as entidades visualizem os recursos do Kubernetes no console do Amazon EKS, conceda as [permissões necessárias](view-kubernetes-resources.md#view-kubernetes-resources-permissions) às entidades.
+  [Configurar o registro em log para o seu cluster](control-plane-logs.md) 
+ Familiarize-se com o que acontece durante [desconexões de rede](eks-outposts-network-disconnects.md).
+  [Adicionar nós ao seu cluster](eks-outposts-self-managed-nodes.md) 
+ Pense em configurar um plano de backup para seu `etcd`. O Amazon EKS não é compatível com backup e restauração automatizadas do `etcd` para clusters locais. Para obter mais informações, consulte [Backing up an etcd cluster](https://kubernetes.io/docs/tasks/administer-cluster/configure-upgrade-etcd/#backing-up-an-etcd-cluster) na documentação do Kubernetes. As duas principais opções estão usando o `etcdctl` para automatizar a captura de snapshots ou o uso do backup de volume de armazenamento do Amazon EBS.