Pré-requisitos Implantação de um workspace Configuração do cluster para gravação remota

Gerencie o Amazon Managed Service para Prometheus AWS com controladores para Kubernetes

O Amazon Managed Service for Prometheus é integrado aos AWS Controllers for Kubernetes (ACK), com suporte para gerenciar seus recursos de workspace, Alert Manager e Ruler no Amazon EKS. Você pode usar AWS controladores para definições de recursos (CRDs) personalizadas 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 e o controlador ACK para o Amazon Managed Service for Prometheus.

Pré-requisitos

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 para criar programaticamente as funções do Amazon Managed Service para Prometheus e IAM.
Você deve ter um cluster do Amazon EKS 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 YOUR_CLUSTER_NAME e AWS_REGION 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 e Criação de um provedor OIDC do IAM no Guia do usuário do Amazon EKS.
Você deve ter o driver da CSI do Amazon EBS instalado no seu cluster do Amazon EKS.
É necessário ter a AWS CLI instalada. O AWS CLI é usado para chamar a AWS funcionalidade a partir da linha de comando.
O Helm, o gerenciador de pacotes do Kubernetes, deve estar instalado.
As métricas do ambiente de gerenciamento com o Prometheus devem ser configuradas em seu cluster do Amazon EKS.
Você deve ter um tópico do Amazon Simple Notiﬁcation Service (Amazon SNS) para o qual você deseja enviar alertas do seu novo workspace. Verifique se você concedeu permissão ao Amazon Managed Service for Prometheus para enviar mensagens para o tópico.

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

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

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 na documentação de AWS Controllers for Kubernetes em. GitHub Use a região correta para 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 | grep '"tag_name":' | cut -d'"' -f4`
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.

Crie um arquivo denominado workspace.yaml com o seguinte texto. Ele será usado como configuração para o workspace 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

Execute o comando a seguir para criar seu workspace (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 workspace, chamado my-amp-workspace em sua conta.

Executando o comando a seguir para visualizar os detalhes e o status do seu workspace, incluindo o ID do workspace. Como alternativa, você pode visualizar o novo workspace no console do Amazon Managed Service for Prometheus.
```
kubectl describe workspace my-amp-workspace -n $ACK_SYSTEM_NAMESPACE
```
nota
Você também pode usar um workspace existente em vez de criar um novo.

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. Substitua WORKSPACE-ID pelo ID do workspace 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. Substitua WORKSPACE-ID pelo ID do workspace da etapa anterior. Substitua TOPIC-ARN pelo ARN do tópico do Amazon SNS para enviar notificações e REGION pelo que você está usando. Região da AWS Lembre-se de que o Amazon Managed Service for Prometheus deve ter permissões 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 AlertManagerDefinitionDatae.

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. ResourceTypeSubstitua pelo tipo de recurso que você deseja excluir WorkspaceAlertManagerDefinition, ouRuleGroupNamespace. ResourceNameSubstitua pelo nome do recurso a ser excluído.
```
kubectl delete ResourceType ResourceName -n $ACK_SYSTEM_NAMESPACE
```

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

Configuração do cluster do Amazon EKS para gravar no workspace do Amazon Managed Service for Prometheus

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 workspace 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 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

Use o comando a seguir para obter o prometheusEndpoint para o workspace. Substitua WORKSPACE-ID pelo ID do workspace 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.

Crie um arquivo com o texto a seguir e chame-o de prometheus-config.yaml. Substitua a conta pelo ID da sua conta, workspaceURL/ pelo URL que você acabou de encontrar e a região pela Região da AWS apropriada 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

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
Execute o comando a seguir PrometheusChartName, usando o PrometheusNamespace,, e PrometheusChartVersionencontrado 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.
Opcionalmente, valide se as métricas estão sendo enviadas com êxito consultando o endpoint do Amazon Managed Service for Prometheus via awscurl. Substitua Region pela Região da AWS que você está usando e workspaceURL/ pela URL encontrada na etapa 1.
```
awscurl --service="aps" --region="Region" "workspaceURL/api/v1/query?query=node_cpu_seconds_total"
```

Agora você criou um workspace 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), estão localizados em seu cluster do 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.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

AWS Acelerador de observabilidade

CloudWatch Métricas da Amazon com Firehose