Configurer des fournisseurs d’identité externes avec l’authentification structurée AKS (préversion)

Configurer l’authentification OIDC pour GitHub Actions

1. Vérifiez que vos flux de travail GitHub Actions disposent des autorisations nécessaires.

2. Configurez l’autorisation id-token: write dans vos fichiers de flux de travail. Par exemple:

   permissions:
     id-token: write
     contents: read
   

3. Configurez les paramètres de référentiel et d’organisation appropriés pour l’accès aux jetons OIDC. Configurez les paramètres OIDC du référentiel et les stratégies de sécurité de l’organisation pour l’utilisation des jetons.

Configurer l’authentification OAuth 2.0 d’identité Google

1. Accédez à la console Google Cloud.
2. Créez ou sélectionnez un projet.
3. Créez des informations d’identification OAuth 2.0.
4. Notez votre ID client et votre clé secrète client pour une utilisation ultérieure.

Créer une configuration d’authentificateur JWT pour GitHub Actions OIDC

• Créez un fichier nommé jwt-config.json avec la configuration suivante :

  {
    "issuer": {
        "url": "https://token.actions.githubusercontent.com",
        "audiences": [
            "my-api"
        ]
    },
    "claimValidationRules": [
        {
            "expression": "has(claims.sub)",
            "message": "must have sub claim"
        }
    ],
    "claimMappings": {
        "username": {
            "expression": "'aks:jwt:github:' + claims.sub"
        }
    },
    "userValidationRules": [
        {
            "expression": "has(user.username)",
            "message": "must have username"
        },
        {
            "expression": "!user.username.startsWith('aks:jwt:github:system')",
            "message": "username must not start with 'aks:jwt:github:system'"
        }
    ]
  }
  

Créer une configuration d’authentificateur JWT pour Google Identity

• Créez un fichier nommé jwt-config.json avec la configuration suivante :

  {
      "issuer": {
          "url": "https://accounts.google.com",
          "audiences": [
              "your-client-id.apps.googleusercontent.com"
          ]
      },
      "claimValidationRules": [
          {
              "expression": "has(claims.sub)",
              "message": "must have sub claim"
          }
      ],
      "claimMappings": {
          "username": {
              "expression": "'aks:jwt:google:' + claims.sub"
          },
          "groups": {
              "expression": "has(claims.groups) ? claims.groups.split(',').map(g, 'aks:jwt:' + g) : []"
          }
      },
      "userValidationRules": [
          {
              "expression": "has(user.username)",
              "message": "must have username"
          },
          {
              "expression": "!user.username.startsWith('aks:jwt:google:system')",
              "message": "username must not start with 'aks:jwt:google:system'"
          }
      ]
  }
  

Configurer GitHub Actions OIDC pour l’authentification

1. Créez des variables d’environnement pour et définissez les secrets de référentiel requis suivants dans votre dépôt GitHub :

   • AKS_SERVER_URL: URL du serveur d’API de votre cluster AKS.
   • AKS_CA_DATA: Données d’autorité de certification codées en base64 pour votre cluster AKS.

2. Créez un flux de travail qui obtient un jeton OIDC et l’utilise pour s’authentifier auprès de votre cluster AKS. L’exemple de workflow suivant récupère tous les pods en cours d’exécution sur le cluster :

   Note

   La valeur my-api de l’audience doit correspondre à l’audience configurée dans votre configuration d’authentificateur JWT.

   name: AKS Access with GitHub OIDC
   on:
     workflow_dispatch:
     push:
       branches: [main]
   
   permissions:
     id-token: write
     contents: read
   
   jobs:
     aks-access:
       runs-on: ubuntu-latest
       steps:
         - name: Checkout code
           uses: actions/checkout@v4
   
         - name: Install kubectl
           uses: azure/setup-kubectl@v3
           with:
             version: 'latest'
   
         - name: Get GitHub OIDC token
           id: get_token
           run: |
             TOKEN=$(curl -H "Authorization: Bearer $ACTIONS_ID_TOKEN_REQUEST_TOKEN" \
               "$ACTIONS_ID_TOKEN_REQUEST_URL&audience=my-api" | \
               jq -r '.value')
             echo "::add-mask::$TOKEN"
             echo "oidc_token=$TOKEN" >> $GITHUB_OUTPUT
   
         - name: Create kubeconfig with OIDC token
           run: |
             cat <<EOF > kubeconfig
             apiVersion: v1
             kind: Config
             clusters:
             - cluster:
                 certificate-authority-data: ${{ secrets.AKS_CA_DATA }}
                 server: ${{ secrets.AKS_SERVER_URL }}
               name: aks-cluster
             contexts:
             - context:
                 cluster: aks-cluster
                 user: github-oidc-user
               name: aks-context
             current-context: aks-context
             users:
             - name: github-oidc-user
               user:
                 token: ${{ steps.get_token.outputs.oidc_token }}
             EOF
   
         - name: List all pods in the cluster
           run: |
             export KUBECONFIG=./kubeconfig
             kubectl get pods --all-namespaces
   

Obtenir des informations sur le cluster pour la configuration de l’authentificateur JWT

1. Obtenez l’URL du serveur d’API pour votre cluster à l’aide de la az aks show commande.

   az aks show --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --query "fqdn" -o tsv | \
     awk '{print "https://" $0 ":443"}'
   

2. Obtenez les données d’autorité de certification encodées en base64 pour votre cluster à l’aide de la az aks get-credentials commande.

   # Get CA data (base64 encoded)
   az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME --file - --format exec | \
     grep certificate-authority-data | awk '{print $2}'
   

Configurer Google Identity OAuth 2.0 pour l’authentification

Vous pouvez configurer l’authentification Google Identity à l’aide du kubelogin plug-in ou directement à l’aide d’un jeton statique.

1. Déclenchez le flux de travail en envoyant (push) vers la branche principale ou en le déclenchant manuellement à partir de l’onglet Actions de votre référentiel.

2. Surveillez l’exécution du flux de travail sous l’onglet Actions pour vérifier que l’authentification fonctionne.

   Sortie attendue pour la première installation avant la configuration Role-Based Access Control (RBAC) :

   Error from server (Forbidden): nodes is forbidden: User "aks:jwt:github:your-sub" cannot list resource "nodes" in API group "" at the cluster scope
   

   Cette erreur indique la réussite de l’authentification, mais le manque d’autorisation.

• Testez l’authentification à l’aide de la kubectl get nodes commande avec l’indicateur --user pour spécifier le contexte utilisateur que vous avez créé pour l’authentification Google Identity. Par exemple:

  kubectl get nodes --user external-user
  

  Sortie attendue pour la première installation avant la configuration Role-Based Access Control (RBAC) :

  Error from server (Forbidden): nodes is forbidden: User "aks:jwt:google:your-subject" cannot list resource "nodes" in API group "" at the cluster scope
  

  Cette erreur indique la réussite de l’authentification, mais le manque d’autorisation.

1. Créez un fichier nommé rbac-config.yaml pour configurer des liaisons RBAC pour les utilisateurs externes. Par exemple:

   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: external-user-role
   rules:
   - apiGroups: [""]
     resources: ["pods", "services", "nodes"]
     verbs: ["get", "list"]
   - apiGroups: ["apps"]
     resources: ["deployments", "replicasets"]
     verbs: ["get", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: external-user-binding
   subjects:
   - kind: User
     # This matches the username expression in claim mappings for GitHub; example of GitHub subject is "repo:<organization-name>/<repository-name>:ref:refs/heads/main"
     name: aks:jwt:github:your-github-sub
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: ClusterRole
     name: external-user-role
     apiGroup: rbac.authorization.k8s.io
   

2. Appliquez la configuration RBAC à l’aide de la kubectl apply commande :

   kubectl apply -f rbac-config.yaml
   

1. Créez un fichier nommé rbac-config.yaml pour configurer des liaisons RBAC pour les utilisateurs externes. Par exemple:

   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRole
   metadata:
     name: external-user-role
   rules:
   - apiGroups: [""]
     resources: ["pods", "services", "nodes"]
     verbs: ["get", "list"]
   - apiGroups: ["apps"]
     resources: ["deployments", "replicasets"]
     verbs: ["get", "list"]
   ---
   apiVersion: rbac.authorization.k8s.io/v1
   kind: ClusterRoleBinding
   metadata:
     name: external-user-binding
   subjects:
   - kind: User
     # This matches the username expression in claim mappings for Google
     name: aks:jwt:google:your-subject-claim
     apiGroup: rbac.authorization.k8s.io
   roleRef:
     kind: ClusterRole
     name: external-user-role
     apiGroup: rbac.authorization.k8s.io
   

2. Appliquez la configuration RBAC à l’aide de la kubectl apply commande :

   kubectl apply -f rbac-config.yaml