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

Artigo
10/03/2024

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

Pré-requisitos

São necessárias versões do Prometheus superiores à v2.48 para a autenticação da aplicação Microsoft Entra ID.
Prometeu em execução no cluster. Este artigo pressupõe que o cluster Prometheus é configurado usando a pilha kube-prometheus, mas você pode configurar Prometheus usando outros métodos.

Configurar a gravação remota com o ID de carga de trabalho do Microsoft Entra

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

Habilite o OpenID Connect e anote o URL do emissor.
Configure o webhook de admissão mutante.
Configure a identidade da carga de trabalho.
Crie um aplicativo Microsoft Entra ou uma identidade gerenciada atribuída pelo usuário e conceda permissões.
Atribua a função Monitoring Metrics Publisher na regra de coleta de dados do espaço de trabalho ao aplicativo.
Crie ou atualize sua conta de serviço Kubernetes Prometheus pod.
Estabeleça credenciais de identidade federada entre a identidade e o emissor e o assunto da conta de serviço.
Implante 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 consulte o Emissor

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

Uma vez ativado, anote o SERVICE_ACCOUNT_ISSUER que é essencialmente o URL do emissor do OIDC. Para obter a URL do emissor OIDC, execute o comando az aks show . Substitua os valores padrão para o nome do cluster e o 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 https://{region}.oic.prod-aks.azure.combase, onde o valor para {region} corresponde ao local em que o cluster AKS está implantado.

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

Configurar webhook de admissão mutante

Configure o webhook de admissão mutante para manter as credenciais federadas atualizadas. Consulte Webhook de admissão mutante - ID de carga de trabalho do Microsoft Entra para configurar.

Configurar a identidade da 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 seu pod Prometheus. Use esse valor, se ele existir. Para encontrar 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 existir, introduza o nome da conta de serviço que pretende associar ao seu pod Prometheus.

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

Crie um aplicativo Microsoft Entra ou uma identidade gerenciada atribuída pelo usuário e conceda permissão para publicar métricas no espaço de trabalho 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}"

Atribua a função Publicador de Métricas de Monitoramento na regra de coleta de dados do espaço de trabalho ao aplicativo ou à identidade gerenciada

Para obter informações sobre como atribuir a função, consulte Atribuir a função Monitoring Metrics Publisher na regra de coleta de dados do espaço de trabalho à identidade gerenciada.

Crie ou atualize sua conta de serviço Kubernetes Prometheus pod

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

Se nenhuma conta de serviço do Kubernetes, exceto a conta de serviço padrão, estiver associada ao Prometheus, crie uma nova 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 uma conta de serviço do Kubernetes diferente da conta de serviço padrão estiver associada ao seu pod, 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 Microsoft Entra ou a identidade gerenciada atribuída pelo usuário não estiver 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

Estabelecer 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 gerida atribuída pelo utilizador

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}"

Aplicação 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

A cápsula de 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 mostrado na página Visão geral do espaço de trabalho do Azure Monitor
LISTENING_PORT: 8081 (qualquer porta é suportada)
IDENTITY_TYPE: workloadIdentity

Copie o seguinte YAML e salve-o em um arquivo. O YAML usa a porta 8081 como porta de escuta. Se você usar 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 seguintes valores no YAML:

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

Use o Helm para aplicar o arquivo YAML e atualizar sua 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 resolução de problemas

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

Partilhar via