As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Gerencie o Amazon Managed Service para Prometheus AWS com controladores para Kubernetes
<a name="integrating-ack"></a>

O Amazon Managed Service for Prometheus é integrado aos [AWS Controllers for Kubernetes (ACK)](https://aws-controllers-k8s.github.io/community/docs/community/overview/), com suporte para gerenciar seus recursos de espaço de trabalho, Alert Manager e Ruler no Amazon EKS. Você pode usar AWS controladores para definições de recursos personalizadas (CRDs) do Kubernetes e objetos nativos do Kubernetes sem precisar definir nenhum recurso fora do seu cluster.

Esta seção descreve como configurar AWS controladores para Kubernetes e Amazon Managed Service para Prometheus em um cluster Amazon EKS existente.

Você também pode ler as postagens do blog que [apresentam AWS os controladores para Kubernetes](https://aws.amazon.com/blogs/containers/aws-controllers-for-kubernetes-ack/) e [o controlador ACK para o Amazon Managed Service for Prometheus](https://aws.amazon.com/blogs/mt/introducing-the-ack-controller-for-amazon-managed-service-for-prometheus/).

## Pré-requisitos
<a name="ack-prereqs"></a>

Antes de começar a integrar AWS os Controllers for Kubernetes e o Amazon Managed Service for Prometheus com seu cluster Amazon EKS, você deve ter os seguintes pré-requisitos.
+ Você deve ter uma conta [existente Conta da AWS e ter permissões](AMP-setting-up.md) para criar programaticamente as funções do Amazon Managed Service para Prometheus e IAM.
+ Você deve ter um [cluster do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-console.html) existente com o OpenID Connect (OIDC) habilitado.

  Se o OIDC não estiver habilitado, você pode usar o comando a seguir para habilitá-lo. Lembre-se de substituir o *YOUR\$1CLUSTER\$1NAME* e *AWS\$1REGION* pelos valores corretos para sua conta.

  ```
  eksctl utils associate-iam-oidc-provider \
      --cluster ${YOUR_CLUSTER_NAME} --region ${AWS_REGION} \
      --approve
  ```

  Para obter mais informações sobre o uso do OIDC com o Amazon EKS, consulte [Autenticação do provedor de identidade do OIDC](https://docs.aws.amazon.com/eks/latest/userguide/authenticate-oidc-identity-provider.html) e [Criação de um provedor OIDC do IAM](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) no *Guia do usuário do Amazon EKS*. 
+ Você deve ter o [driver da CSI do Amazon EBS instalado](https://docs.aws.amazon.com/eks/latest/userguide/ebs-csi.html) no seu cluster do Amazon EKS.
+ É necessário ter a [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) instalada. O AWS CLI é usado para chamar a AWS funcionalidade a partir da linha de comando.
+ O [Helm](https://docs.aws.amazon.com/eks/latest/userguide/helm.html), o gerenciador de pacotes do Kubernetes, deve estar instalado.
+ [As métricas do ambiente de gerenciamento com o Prometheus](https://docs.aws.amazon.com/eks/latest/userguide/prometheus.html) devem ser configuradas em seu cluster do Amazon EKS.
+ Você deve ter um tópico do [Amazon Simple Notification Service (Amazon SNS)](https://docs.aws.amazon.com/sns/) para o qual você deseja enviar alertas do seu novo espaço de trabalho. Verifique se você [concedeu permissão ao Amazon Managed Service for Prometheus para enviar mensagens para o tópico](AMP-alertmanager-receiver-AMPpermission.md).

Quando seu cluster do Amazon EKS estiver configurado adequadamente, você poderá ver as métricas formatadas para o Prometheus chamando `kubectl get --raw /metrics`. Agora você está pronto para instalar um controlador de serviço AWS Controllers for Kubernetes e usá-lo para implantar recursos do Amazon Managed Service for Prometheus.

## Implantação de um espaço de trabalho com AWS controladores para Kubernetes
<a name="ack-deploy-workspace"></a>

Para implantar um novo espaço de trabalho do Amazon Managed Service para Prometheus, você instalará AWS um controlador Controllers for Kubernetes e o usará para criar o espaço de trabalho.

**Para implantar um novo espaço de trabalho AWS do Amazon Managed Service para Prometheus com controladores para Kubernetes**

1. Use os comandos a seguir para usar o Helm para instalar o controlador de serviço do Amazon Managed Service for Prometheus. Para obter mais informações, consulte [Instalar um controlador ACK](https://aws-controllers-k8s.github.io/community/docs/user-docs/install/) na documentação de AWS Controllers for Kubernetes em. GitHub Use o correto *region* para o seu sistema, como`us-east-1`.

   ```
   export SERVICE=prometheusservice
   export RELEASE_VERSION=`curl -sL https://api.github.com/repos/aws-controllers-k8s/$SERVICE-controller/releases/latest | jq -r '.tag_name | ltrimstr("v")'`
   export ACK_SYSTEM_NAMESPACE=ack-system
   export AWS_REGION=region
   
   aws ecr-public get-login-password --region us-east-1 | helm registry login --username AWS --password-stdin public.ecr.aws
   helm install --create-namespace -n $ACK_SYSTEM_NAMESPACE ack-$SERVICE-controller \
     oci://public.ecr.aws/aws-controllers-k8s/$SERVICE-chart --version=$RELEASE_VERSION --set=aws.region=$AWS_REGION
   ```

   Após alguns instantes, você verá um resultado semelhante ao seguinte, indicando êxito.

   ```
   You are now able to create Amazon Managed Service for Prometheus (AMP) resources!
   The controller is running in "cluster" mode.
   The controller is configured to manage AWS resources in region: "us-east-1"
   ```

   Opcionalmente, você pode verificar se o AWS controlador Controllers for Kubernetes foi instalado com êxito com o comando a seguir.

   ```
   helm list --namespace $ACK_SYSTEM_NAMESPACE -o yaml
   ```

   Isso retornará informações sobre o controlador `ack-prometheusservice-controller`, incluindo o `status: deployed`.

1. Crie um arquivo denominado `workspace.yaml` com o seguinte texto. Ele será usado como configuração para o espaço de trabalho que você está criando.

   ```
   apiVersion: prometheusservice.services.k8s.aws/v1alpha1
   kind: Workspace
   metadata:
     name: my-amp-workspace
   spec:
     alias: my-amp-workspace
     tags:
       ClusterName: EKS-demo
   ```

1. Execute o comando a seguir para criar seu espaço de trabalho (esse comando depende das variáveis do sistema que você configurou na etapa 1).

   ```
   kubectl apply -f workspace.yaml -n $ACK_SYSTEM_NAMESPACE
   ```

   Em alguns instantes, você poderá ver um novo espaço de trabalho, chamado `my-amp-workspace` em sua conta.

   Executando o comando a seguir para visualizar os detalhes e o status do seu espaço de trabalho, incluindo o *ID do espaço de trabalho*. Como alternativa, você pode visualizar o novo espaço de trabalho no [console do Amazon Managed Service for Prometheus](https://console.aws.amazon.com/prometheus).

   ```
   kubectl describe workspace my-amp-workspace -n $ACK_SYSTEM_NAMESPACE
   ```
**nota**  
Você também pode [usar um espaço de trabalho existente](https://aws-controllers-k8s.github.io/community/docs/user-docs/adopted-resource/) em vez de criar um novo.

1. Crie dois novos arquivos yaml como configuração para os grupos de regras e AlertManager que você criará em seguida usando a configuração a seguir.

   Salve essa configuração como `rulegroup.yaml`. *WORKSPACE-ID*Substitua pela ID do espaço de trabalho da etapa anterior.

   ```
   apiVersion: prometheusservice.services.k8s.aws/v1alpha1
   kind: RuleGroupsNamespace
   metadata:
     name: default-rule
   spec:
     workspaceID: WORKSPACE-ID
     name: default-rule
     configuration: |
       groups:
       - name: example
         rules:
         - alert: HostHighCpuLoad
           expr: 100 - (avg(rate(node_cpu_seconds_total{mode="idle"}[2m])) * 100) > 60
           for: 5m
           labels:
             severity: warning
             event_type: scale_up
           annotations:
             summary: Host high CPU load (instance {{ $labels.instance }})
             description: "CPU load is > 60%\n  VALUE = {{ $value }}\n  LABELS = {{ $labels }}"
         - alert: HostLowCpuLoad
           expr: 100 - (avg(rate(node_cpu_seconds_total{mode="idle"}[2m])) * 100) < 30
           for: 5m
           labels:
             severity: warning
             event_type: scale_down
           annotations:
             summary: Host low CPU load (instance {{ $labels.instance }})
             description: "CPU load is < 30%\n  VALUE = {{ $value }}\n  LABELS = {{ $labels }}"
   ```

   Salve a configuração a seguir como `alertmanager.yaml`. *WORKSPACE-ID*Substitua pela ID do espaço de trabalho da etapa anterior. *TOPIC-ARN*Substitua pelo ARN do tópico do Amazon SNS para o qual enviar notificações *REGION* e pelo que você está usando Região da AWS . Lembre-se de que o Amazon Managed Service for Prometheus [deve ter permissões](AMP-alertmanager-receiver-AMPpermission.md) para o tópico do Amazon SNS.

   ```
   apiVersion: prometheusservice.services.k8s.aws/v1alpha1
   kind: AlertManagerDefinition
   metadata:
     name: alert-manager
   spec:
     workspaceID: WORKSPACE-ID
     configuration: |
       alertmanager_config: |
         route:
            receiver: default_receiver
         receivers:
           - name: default_receiver
             sns_configs:
             - topic_arn: TOPIC-ARN
               sigv4:
                 region: REGION
               message: |
                 alert_type: {{ .CommonLabels.alertname }}
                 event_type: {{ .CommonLabels.event_type }}
   ```
**nota**  
Para saber mais sobre os formatos desses arquivos de configuração, consulte [RuleGroupsNamespaceData](https://docs.aws.amazon.com/prometheus/latest/APIReference/yaml-RuleGroupsNamespaceData.html) e [AlertManagerDefinitionData](https://docs.aws.amazon.com/prometheus/latest/APIReference/yaml-AlertManagerDefinitionData.html).

1. Execute os comandos a seguir para criar seu grupo de regras e a configuração do gerenciador de alertas (esse comando depende das variáveis do sistema que você configurou na etapa 1).

   ```
   kubectl apply -f rulegroup.yaml -n $ACK_SYSTEM_NAMESPACE
   kubectl apply -f alertmanager.yaml -n $ACK_SYSTEM_NAMESPACE
   ```

   As mudanças estarão disponíveis em instantes.
**nota**  
Para atualizar um recurso, em vez de criá-lo, basta atualizar o arquivo yaml e executar o comando `kubectl apply` novamente.  
Para excluir um recurso, execute o comando a seguir. *ResourceType*Substitua pelo tipo de recurso que você deseja excluir `Workspace``AlertManagerDefinition`, ou`RuleGroupNamespace`. *ResourceName*Substitua pelo nome do recurso a ser excluído.  

   ```
   kubectl delete ResourceType ResourceName -n $ACK_SYSTEM_NAMESPACE
   ```

Isso conclui a implantação do novo espaço de trabalho. A próxima seção descreve como configurar seu cluster para enviar métricas para esse espaço de trabalho.

## Configuração do cluster do Amazon EKS para gravar no espaço de trabalho do Amazon Managed Service for Prometheus
<a name="ack-configure-workspace"></a>

Esta seção descreve como usar o Helm para configurar o Prometheus em execução no seu cluster do Amazon EKS para gravar de forma remota métricas no espaço de trabalho do Amazon Managed Service for Prometheus que você criou na seção anterior.

Para esse procedimento, você precisará do nome do perfil do IAM que você criou para usar na ingestão de métricas. Se ainda não o tiver feito isso, consulte [Configurar perfis de serviço para a ingestão de métricas de clusters do Amazon EKS](set-up-irsa.md#set-up-irsa-ingest) para obter mais informações e instruções. Se você seguir essas instruções, o perfil do IAM será chamado `amp-iamproxy-ingest-role`.

**Para configurar o cluster do Amazon EKS para gravação remota**

1. Use o comando a seguir para obter o `prometheusEndpoint` para o espaço de trabalho. *WORKSPACE-ID*Substitua pela ID do espaço de trabalho da seção anterior.

   ```
   aws amp describe-workspace --workspace-id WORKSPACE-ID
   ```

   O prometheusEndpoint estará nos resultados de retorno e será formatado assim:

   ```
   https://aps-workspaces.us-west-2.amazonaws.com/workspaces/ws-a1b2c3d4-a123-b456-c789-ac1234567890/
   ```

   Salve esse URL para uso nas próximas etapas.

1. Crie um arquivo com o texto a seguir e chame-o de `prometheus-config.yaml`. *account*Substitua pelo ID da sua conta, *workspaceURL/* pelo URL que você acabou de encontrar e *region* pelo apropriado Região da AWS para o seu sistema.

   ```
   serviceAccounts:
           server:
               name: "amp-iamproxy-ingest-service-account"
               annotations:
                   eks.amazonaws.com/role-arn: "arn:aws:iam::account:role/amp-iamproxy-ingest-role"
   server:
       remoteWrite:
           - url: workspaceURL/api/v1/remote_write
             sigv4:
               region: region
             queue_config:
               max_samples_per_send: 1000
               max_shards: 200
               capacity: 2500
   ```

1. Encontre os nomes do gráfico e do namespace do Prometheus, bem como a versão do gráfico, com o seguinte comando Helm.

   ```
   helm ls --all-namespaces
   ```

   Com base nas etapas até aqui, o gráfico e o namespace do Prometheus devem ser nomeados `prometheus`, e a versão do gráfico pode ser `15.2.0`

1. Execute o comando a seguir*PrometheusChartName*, usando o*PrometheusNamespace*,, e *PrometheusChartVersion* encontrado na etapa anterior.

   ```
   helm upgrade PrometheusChartName prometheus-community/prometheus -n PrometheusNamespace -f prometheus-config.yaml --version PrometheusChartVersion
   ```

   Depois de alguns minutos, você verá uma mensagem informando que a atualização ocorreu com êxito.

1. Opcionalmente, valide se as métricas estão sendo enviadas com êxito consultando o endpoint do Amazon Managed Service for Prometheus via `awscurl`. *Region*Substitua pelo Região da AWS que você está usando e *workspaceURL/* pelo URL encontrado na etapa 1.

   ```
   awscurl --service="aps" --region="Region" "workspaceURL/api/v1/query?query=node_cpu_seconds_total"
   ```

Agora você criou um espaço de trabalho do Amazon Managed Service for Prometheus e se conectou a ele a partir do seu cluster do Amazon EKS usando arquivos YAML como configuração. Esses arquivos, chamados de definições de recursos personalizados (CRDs), residem em seu cluster Amazon EKS. Você pode usar o controlador AWS Controllers for Kubernetes para gerenciar todos os seus recursos do Amazon Managed Service for Prometheus diretamente do cluster.