**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.
# Comece a usar o AWS Fargate em seu cluster
Este tópico descreve como começar a executar pods no AWS Fargate com o cluster do Amazon EKS.
Se você restringir o acesso ao endpoint público do cluster usando blocos CIDR, é recomendável também habilitar o acesso ao endpoint privado. Dessa forma, os pods do Fargate podem se comunicar com o cluster. Sem o endpoint privado ativado, os blocos CIDR especificados para acesso público devem incluir as origens de saída da VPC. Para obter mais informações, consulte [Endpoint do servidor de API do cluster](cluster-endpoint.md).
**Pré-requisito**
Um cluster existente. Se você ainda não tem um cluster do Amazon EKS, consulte [Começar a usar o Amazon EKS](getting-started.md).
## Etapa 1: verificar se os nós existentes podem se comunicar com os pods do Fargate
Se estiver trabalhando com um novo cluster sem nós ou um cluster com apenas grupos de nós gerenciados (consulte [Simplificar o ciclo de vida dos nós com grupos de nós gerenciados](managed-node-groups.md)), pule para [Etapa 2: criar um perfil de execução de pods do Fargate](#fargate-sg-pod-execution-role).
Pressuponha que você esteja trabalhando com um cluster existente que já tenha nós associados a ele. Verifique se os pods nesses nós podem se comunicar livremente com os pods em execução no Fargate. Os pods em execução no Fargate são automaticamente configurados para usar o grupo de segurança do cluster para o cluster ao qual estão associados. Certifique-se de que todos os nós existentes em seu cluster possam enviar e receber tráfego de e para o grupo de segurança do cluster. Os grupos de nós gerenciados são configurados automaticamente para usar também o grupo de segurança do cluster, portanto, não é necessário modificá-los ou verificá-los quanto a essa compatibilidade (consulte [Simplificar o ciclo de vida dos nós com grupos de nós gerenciados](managed-node-groups.md)).
Para grupos de nós existentes que foram criados com `eksctl` ou com os modelos AWS CloudFormation gerenciados pelo Amazon EKS, você pode adicionar manualmente o grupo de segurança do cluster aos nós. Ou então, pode modificar o modelo de lançamento do grupo do Auto Scaling para o grupo de nós para anexar o grupo de segurança do cluster às instâncias. Para obter mais informações, consulte [Alterar os grupos de segurança de uma instância](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html#SG_Changing_Group_Membership) no *Guia do usuário da Amazon VPC*.
Você pode conferir se há um grupo de segurança para o seu cluster no Console de gerenciamento da AWS, na seção **Networking** (Rede). Ou você pode fazer isso usando o seguinte comando da CLI AWS. Quando usar esse comando, substitua `` pelo nome de seu cluster.
```
aws eks describe-cluster --name --query cluster.resourcesVpcConfig.clusterSecurityGroupId
```
## Etapa 2: criar um perfil de execução de pods do Fargate
Quando o cluster cria pods no AWS Fargate, os componentes que são executados na infraestrutura do Fargate devem fazer as chamadas para as APIs da AWS em seu nome. O perfil de execução de pods do Amazon EKS fornece as permissões do IAM para fazer isso. Para criar um perfil de execução de pods do AWS Fargate, consulte [Perfil do IAM de execução de pods do Amazon EKS](pod-execution-role.md).
**nota**
Se você criou o cluster com o `eksctl` usando a opção `--fargate`, ele já tem um perfil de execução de pods que você pode encontrar no console do IAM com o padrão `eksctl-my-cluster-FargatePodExecutionRole-ABCDEFGHIJKL`. Da mesma forma, se você usar o `eksctl` para criar os perfis do Fargate, o `eksctl` criará o perfil de execução de pods, caso ainda não tenha sido criado.
## Etapa 3: criar um perfil do Fargate para o cluster
Antes de agendar os pods em execução no Fargate no cluster, é necessário definir um perfil do Fargate que especifique quais pods deverão usá-lo quando forem executados. Para obter mais informações, consulte [Definir quais pods usam o AWS Fargate quando iniciado](fargate-profile.md).
**nota**
Se você criou o cluster com o `eksctl` usando a opção `--fargate`, um perfil do Fargate já foi criado para o cluster com seletores para todos os pods nos namespaces `kube-system` e `default`. Use o procedimento a seguir para criar perfis do Fargate para qualquer outro namespace que você deseja usar com o Fargate.
Você pode criar um perfil do Fargate usando qualquer uma dessas ferramentas:
+ [`eksctl`](#eksctl_fargate_profile_create)
+ [Console de gerenciamento da AWS](#console_fargate_profile_create)
### `eksctl`
Este procedimento exige a versão `eksctl` `0.215.0` ou superior. Você pode verificar a versão com o seguinte comando:
```
eksctl version
```
Para obter instruções sobre como instalar ou atualizar o `eksctl`, consulte [Instalação](https://eksctl.io/installation) na documentação do `eksctl`.
**Para criar um perfil do Fargate com o `eksctl` **
Crie o perfil do Fargate com o comando `eksctl` a seguir, substituindo cada `` por seus próprios valores. Você precisa especificar um namespace. Mas, a opção `--labels` não é exigida.
```
eksctl create fargateprofile \
--cluster \
--name \
--namespace \
--labels
```
É possível usar certos curingas para rótulos `` e `` . Para obter mais informações, consulte [Curingas do perfil do Fargate](fargate-profile.md#fargate-profile-wildcards).
### Console de gerenciamento da AWS
**Para criar um perfil do Fargate com o Console de gerenciamento da AWS **
1. Abra o [console do Amazon EKS](https://console.aws.amazon.com/eks/home#/clusters).
1. Escolha o cluster para o qual deve ser criado um perfil do Fargate.
1. Escolha a guia **Compute** (Computação).
1. Em **Fargate profile** (Perfil do Fargate), escolha **Add Fargate profile** (Adicionar perfil do Fargate).
1. Na página **Configure Fargate profile** (Configurar o perfil do Fargate), faça o seguinte:
1. Em **Name** (Nome), insira um nome para o perfil do Fargate. O nome deve ser exclusivo.
1. Em **Perfil de execução de pods**, escolha o perfil de execução de pod que deve ser usado com o perfil do Fargate. Somente funções do IAM com o principal de serviço do `eks-fargate-pods.amazonaws.com` são mostradas. Se nenhuma função estiver listada, você deve criar uma. Para obter mais informações, consulte [Perfil do IAM de execução de pods do Amazon EKS](pod-execution-role.md).
1. Modifique as **sub-redes** selecionadas conforme necessário.
**nota**
Somente sub-redes privadas são compatíveis com pods em execução no Fargate.
1. Em **Tags** (Etiquetas), você tem a opção de etiquetar o perfil do Fargate. Essas tags não são propagadas para outros recursos associados ao perfil, como pods.
1. Escolha **Próximo**.
1. Na página **Configurar a seleção de pods**, faça o seguinte:
1. Em **Namespace**, insira um namespace para fazer a correspondência com os pods.
+ É possível usar namespaces específicos para a correspondência, como `kube-system` ou `default`.
+ É possível usar certos curingas (por exemplo, `prod-*`) para fazer a correspondência com vários namespaces (por exemplo, `prod-deployment` e `prod-test`). Para obter mais informações, consulte [Curingas do perfil do Fargate](fargate-profile.md#fargate-profile-wildcards).
1. (Opcional) Adicione rótulos do Kubernetes ao seletor. Adicione-os especificamente ao seletor qual os pods no namespace especificado precisam corresponder.
+ É possível adicionar o rótulo `infrastructure: fargate` ao seletor para que somente pods no namespace especificado que também tenham o rótulo `infrastructure: fargate` do Kubernetes correspondam ao seletor.
+ É possível usar certos curingas (por exemplo, `key?: value?`) para fazer a correspondência com vários namespaces (por exemplo, `keya: valuea` e `keyb: valueb`). Para obter mais informações, consulte [Curingas do perfil do Fargate](fargate-profile.md#fargate-profile-wildcards).
1. Escolha **Próximo**.
1. Na página **Review and create** (Revisar e criar), revise as informações do perfil do Fargate e selecione **Create** (Criar).
## Etapa 4: atualizar o CoreDNS
Por padrão, o CoreDNS é configurado para ser executado na infraestrutura do Amazon EC2 nos clusters do Amazon EKS. Se quiser executar *apenas* os pods no Fargate no cluster, conclua as etapas a seguir.
**nota**
Se você criou o cluster com o `eksctl` usando a opção `--fargate`, poderá avançar para [Próximas etapas](#fargate-gs-next-steps).
1. Crie um perfil do Fargate para o CoreDNS com o comando a seguir. Substitua `` pelo nome do cluster, `<111122223333>` pelo ID da conta, `` pelo nome do perfil de execução do pod e `<000000000000000a>`, `<000000000000000b>` e `<000000000000000c>` pelos IDs das sub-redes privadas. Caso não tenha um perfil de execução de pods, você deverá criar um primeiro (consulte [Etapa 2: criar um perfil de execução de pods do Fargate](#fargate-sg-pod-execution-role)).
**Importante**
O ARN da função não pode incluir um [caminho](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-friendly-names) diferente de `/`. Por exemplo, se o nome da sua função for `development/apps/AmazonEKSFargatePodExecutionRole`, você precisará alterá-lo para `AmazonEKSFargatePodExecutionRole` ao especificar o ARN da função. O formato do ARN da função deve ser ` arn:aws:iam::<111122223333>:role/`.
```
aws eks create-fargate-profile \
--fargate-profile-name coredns \
--cluster-name \
--pod-execution-role-arn arn:aws:iam::<111122223333>:role/ \
--selectors namespace=kube-system,labels={k8s-app=kube-dns} \
--subnets subnet-<000000000000000a> subnet-<000000000000000b> subnet-<000000000000000c>
```
1. Acione uma reversão da implantação do `coredns`.
```
kubectl rollout restart -n kube-system deployment coredns
```
## Próximas etapas
+ É possível começar a migrar as aplicações existentes para serem executadas no Fargate com o fluxo de trabalho a seguir.
1. [Criar um perfil do Fargate](fargate-profile.md#create-fargate-profile) que corresponda ao namespace do Kubernetes da aplicação aos rótulos do Kubernetes.
1. Exclua e recrie os pods existentes para que eles sejam agendados no Fargate. Modifique o `` e `` para atualizar seus pods específicos.
```
kubectl rollout restart -n deployment
```
+ Implante o [Roteamento de aplicações e tráfego HTTP com Application Load Balancers](alb-ingress.md) para permitir objetos do Ingress para os pods em execução no Fargate.
+ É possível usar o [Ajuste os recursos do pod com o Vertical Pod Autoscaler](vertical-pod-autoscaler.md) para definir o tamanho inicial correto da CPU e da memória para os pods do Fargate e, em seguida, usar o [Escalar implantações de pods com o Horizontal Pod Autoscaler](horizontal-pod-autoscaler.md) para escalá-los. Se quiser que o Vertical Pod Autoscaler reimplante automaticamente os pods no Fargate com combinações maiores de CPU e memória, defina o modo do Vertical Pod Autoscaler como `Auto` ou `Recreate`. Isso é para garantir a funcionalidade correta. Para obter mais informações, consulte a documentação do [Vertical Pod Autoscaler](https://github.com/kubernetes/autoscaler/tree/master/vertical-pod-autoscaler#quick-start) no GitHub.
+ Você pode configurar o coletor [AWS Distro for OpenTelemetry](https://aws.amazon.com/otel) (ADOT) para monitoramento de aplicações seguindo [estas instruções](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Container-Insights-EKS-otel.html).