Enviar dados do Prometheus para o Azure Monitor usando a autenticação da ID de Carga de Trabalho do Microsoft Entra

Artigo
10/04/2024

Este artigo descreve como configurar a gravação remota para enviar dados do cluster do Prometheus gerenciado pelo Azure Monitor usando a autenticação por ID de carga de trabalho do Microsoft Entra.

Pré-requisitos

Versões do Prometheus acima da v2.48 são necessárias para a autenticação de aplicativo do Microsoft Entra ID.
Prometheus em execução no cluster. Este artigo pressupõe que o cluster Prometheus esteja configurado usando a pilha kube-prometheus, mas você pode configurar o Prometheus usando outros métodos.

Configurar a gravação remota com a ID de Carga de Trabalho do Microsoft Entra

O processo para configurar a gravação remota do Prometheus usando a autenticação da ID de Carga de Trabalho do Microsoft Entra envolve a conclusão das seguintes tarefas:

Habilite o OpenID Connect e anote a URL do emissor.
Configure o webhook de admissão de mutação.
Configurar a identidade de carga de trabalho.
Criar uma identidade gerenciada atribuída pelo usuário ou aplicativo do Microsoft Entra e conceder permissões.
Atribuir ao aplicativo a função de Publicador de Métricas de Monitoramento na regra de coleta de dados do workspace.
Criar ou atualizar o pod Prometheus da sua conta de serviço do Kubernetes.
Estabelecer credenciais de identidade federada entre a identidade e o emissor da conta de serviço e o sujeito.
Implantar um contêiner sidecar para configurar a gravação remota.

As tarefas são descritas nas seções a seguir.

Habilite o OpenID Connect e consultar o Emissor

Para habilitar o OIDC (OpenID Connect) em um cluster do AKS, siga as instruções em Criar um provedor do OpenID Connect no AKS.

Uma vez habilitado, anote o SERVICE_ACCOUNT_ISSUER que é essencialmente a URL do emissor do OIDC. Para obter a URL do emissor do OIDC, execute o comando az aks show. Substitua os valores padrão pelo nome do cluster e pelo nome do grupo de recursos.

az aks show --name myAKScluster --resource-group myResourceGroup --query "oidcIssuerProfile.issuerUrl" -o tsv

Por padrão, o emissor é definido para usar a URL base https://{region}.oic.prod-aks.azure.com, em que o valor para {region} corresponde ao local em que o cluster do AKS está implantado.

Para outros clusters gerenciados (Amazon Elastic Kubernetes Service e Google Kubernetes Engine), consulte Clusters gerenciados – ID de carga de trabalho do Microsoft Entra. Para clusters autogerenciados, confira Clusters autogerenciados – ID de carga de trabalho do Microsoft Entra.

Configure o webhook de admissão de mutação

Configure o webhook de admissão mutáveis para manter as credenciais federadas atualizadas. Consulte Webhook de Admissão de Mutação – ID de Carga de Trabalho do Microsoft Entra para configurar.

Configurar a identidade de carga de trabalho

Para configurar a identidade da carga de trabalho, exporte as seguintes variáveis de ambiente:

# [OPTIONAL] Set this if you're using a Microsoft Entra application
export APPLICATION_NAME="<your application name>"
    
# [OPTIONAL] Set this only if you're using a user-assigned managed identity
export USER_ASSIGNED_IDENTITY_NAME="<your user-assigned managed identity name>"
    
# Environment variables for the Kubernetes service account and federated identity credential
export SERVICE_ACCOUNT_NAMESPACE="<namespace where Prometheus pod is running>"
export SERVICE_ACCOUNT_NAME="<name of service account associated with Prometheus pod. See below for more details>"
export SERVICE_ACCOUNT_ISSUER="<your service account (or OIDC) issuer URL>"

Para SERVICE_ACCOUNT_NAME, verifique se uma conta de serviço (separada da conta de serviço padrão) já está associada ao pod Prometheus. Procure o valor de serviceaccountName ou serviceAccount (preterido) no spec do pod Prometheus. Use esse valor, se ele existir. Para localizar a conta de serviço associada ao pod Prometheus, execute o comando kubectl abaixo:

kubectl get pods/<Promethuespodname> -o yaml

Se serviceaccountName e serviceAccount não existirem, insira o nome da conta de serviço que você gostaria de associar ao pod Prometheus.

Criar uma identidade gerenciada atribuída pelo usuário ou aplicativo do Microsoft Entra e conceder permissões

Crie um aplicativo do Microsoft Entra ou uma identidade gerenciada atribuída pelo usuário e conceda permissão para publicar métricas no workspace do Azure Monitor:

# create a Microsoft Entra application
az ad sp create-for-rbac --name "${APPLICATION_NAME}"

# create a user-assigned managed identity if you use a user-assigned managed identity for this article
az identity create --name "${USER_ASSIGNED_IDENTITY_NAME}" --resource-group "${RESOURCE_GROUP}"

Atribuir à identidade gerenciada a função de Publicador de Métricas de Monitoramento na regra de coleta de dados do workspace

Para obter informações sobre como atribuir a função, confira Atribuir à identidade gerenciada a função de Publicador de Métricas de Monitoramento na regra de coleta de dados do workspace.

Criar ou atualizar o pod Prometheus da sua conta de serviço do Kubernetes

Geralmente, uma conta de serviço do Kubernetes é criada e associada ao pod que executa o contêiner do Prometheus. Se você estiver usando a pilha kube-prometheus, o código criará automaticamente a conta de serviço prometheus-kube-prometheus-prometheus.

Se não houver nenhuma conta de serviço do Kubernetes associada ao Prometheus além da conta de serviço padrão, crie uma conta de serviço especificamente para o pod que executa o Prometheus.

Para criar a conta de serviço, execute o seguinte comando kubectl:

cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: service account
metadata:
  annotations:
    azure.workload.identity/client-id: ${APPLICATION_CLIENT_ID:-$USER_ASSIGNED_IDENTITY_CLIENT_ID}
  name: ${SERVICE_ACCOUNT_NAME}
  namespace: ${SERVICE_ACCOUNT_NAMESPACE}
EOF

Se houver uma conta de serviço do Kubernetes associada ao seu pod (que não seja a conta de serviço padrão), adicione a seguinte anotação à sua conta de serviço:

kubectl annotate sa ${SERVICE_ACCOUNT_NAME} -n ${SERVICE_ACCOUNT_NAMESPACE} azure.workload.identity/client-id="${APPLICATION_OR_USER_ASSIGNED_IDENTITY_CLIENT_ID}" –overwrite

Se o aplicativo do Microsoft Entra ou a identidade gerenciada atribuída pelo usuário não estiverem no mesmo locatário do cluster, adicione a seguinte anotação à sua conta de serviço:

kubectl annotate sa ${SERVICE_ACCOUNT_NAME} -n ${SERVICE_ACCOUNT_NAMESPACE} azure.workload.identity/tenant-id="${APPLICATION_OR_USER_ASSIGNED_IDENTITY_TENANT_ID}" –overwrite

Estabeleça credenciais de identidade federada entre a identidade e o emissor e o assunto da conta de serviço

Crie credenciais federadas usando a CLI do Azure.

Identidade gerenciada atribuída pelo usuário

az identity federated-credential create \
   --name "kubernetes-federated-credential" \
   --identity-name "${USER_ASSIGNED_IDENTITY_NAME}" \
   --resource-group "${RESOURCE_GROUP}" \
   --issuer "${SERVICE_ACCOUNT_ISSUER}" \
   --subject "system:serviceaccount:${SERVICE_ACCOUNT_NAMESPACE}:${SERVICE_ACCOUNT_NAME}"

Aplicativo do Microsoft Entra

# Get the ObjectID of the Microsoft Entra app.

export APPLICATION_OBJECT_ID="$(az ad app show --id ${APPLICATION_CLIENT_ID} --query id -otsv)"

# Add a federated identity credential.

cat <<EOF > params.json
{
  "name": "kubernetes-federated-credential",
  "issuer": "${SERVICE_ACCOUNT_ISSUER}",
  "subject": "system:serviceaccount:${SERVICE_ACCOUNT_NAMESPACE}:${SERVICE_ACCOUNT_NAME}",
  "description": "Kubernetes service account federated credential",
  "audiences": [
    "api://AzureADTokenExchange"
  ]
}
EOF

az ad app federated-credential create --id ${APPLICATION_OBJECT_ID} --parameters @params.json

Implantar um contêiner sidecar para configurar a gravação remota

Importante

O pod Prometheus deve ter o seguinte rótulo: azure.workload.identity/use: "true"

O contêiner sidecar de gravação remota requer os seguintes valores de ambiente:

INGESTION_URL – O ponto de extremidade de ingestão de métricas, conforme mostrado na página Visão geral do workspace do Azure Monitor
LISTENING_PORT: 8081 (qualquer porta é compatível)
IDENTITY_TYPE: workloadIdentity

Copie o YAML a seguir e salve-o em um arquivo. O YAML utiliza a porta 8081 como porta de escuta. Se você estiver usando uma porta diferente, modifique esse valor no YAML.

prometheus:
  prometheusSpec:
    externalLabels:
          cluster: <AKS-CLUSTER-NAME>
    podMetadata:
        labels:
            azure.workload.identity/use: "true"
    ## https://prometheus.io/docs/prometheus/latest/configuration/configuration/#remote_write    
    remoteWrite:
    - url: 'http://localhost:8081/api/v1/write'

    containers:
    - name: prom-remotewrite
      image: <CONTAINER-IMAGE-VERSION>
      imagePullPolicy: Always
      ports:
        - name: rw-port
          containerPort: 8081
      env:
      - name: INGESTION_URL
        value: <INGESTION_URL>
      - name: LISTENING_PORT
        value: '8081'
      - name: IDENTITY_TYPE
        value: workloadIdentity

Substitua os valores a seguir no YAML:

Valor	Descrição
`<CLUSTER-NAME>`	O nome do cluster do AKS.
`<CONTAINER-IMAGE-VERSION>`	`mcr.microsoft.com/azuremonitor/containerinsights/ciprod/prometheus-remote-write/images:prom-remotewrite-20240617.1` Essa é a versão da imagem de contêiner de gravação remota.
`<INGESTION-URL>`	O valor do Ponto de extremidade de ingestão de métricas na página de Visão geral do workspace do Azure Monitor.

Use o Helm para aplicar o arquivo YAML e atualizar a configuração do Prometheus:

# set a context to your cluster 
az aks get-credentials -g <aks-rg-name> -n <aks-cluster-name> 

# use Helm to update your remote write config 
helm upgrade -f <YAML-FILENAME>.yml prometheus prometheus-community/kube-prometheus-stack -namespace <namespace where Prometheus pod resides>

Verificação e solução de problemas

Para obter informações sobre verificação e solução de problemas, veja Solução de problemas de gravação remota e Serviço gerenciado do Azure Monitor para gravação remota do Prometheus.

Compartilhar via