Aller au contenu principal

Chapitre 9.2 - Service Accounts

Objectifs d'Apprentissage​

À la fin de ce chapitre, vous serez capable de:

  • Comprendre ce qu'est un Service Account
  • Créer et utiliser des Service Accounts
  • Lier des Service Accounts à des Pods
  • Comprendre les tokens et secrets
  • Gérer les permissions avec RBAC
  • Utiliser des Service Accounts pour l'accès API

Introduction​

Un Service Account fournit une identité pour les Pods qui s'exécutent dans le cluster. Il permet aux applications d'interagir avec l'API Kubernetes de manière sécurisée.

Qu'est-ce qu'un Service Account?​

Un Service Account est une identité Kubernetes utilisée par les Pods pour:

  • S'authentifier auprès de l'API Kubernetes
  • Accéder aux ressources selon les permissions RBAC
  • Interagir avec d'autres services dans le cluster

Par défaut: Chaque namespace a un Service Account default.

Création d'un Service Account​

Service Account Basique​

apiVersion: v1
kind: ServiceAccount
metadata:
  name: my-app-sa
  namespace: default

Service Account avec Annotations​

apiVersion: v1
kind: ServiceAccount
metadata:
  name: my-app-sa
  namespace: default
  annotations:
    eks.amazonaws.com/role-arn: arn:aws:iam::123456789012:role/my-role

Utilisation dans un Pod​

Spécifier le Service Account​

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  serviceAccountName: my-app-sa
  containers:
  - name: app
    image: my-app:1.0

Résultat: Le Pod utilise my-app-sa au lieu du Service Account par défaut.

Service Account Automatique​

Si serviceAccountName n'est pas spécifié, le Pod utilise le Service Account default du namespace.

Tokens et Secrets​

Token Automatique​

Kubernetes crée automatiquement un token (Secret) pour chaque Service Account:

# Voir les secrets créés automatiquement
kubectl get secrets | grep my-app-sa

# Détails du token
kubectl describe secret my-app-sa-token-xxxxx

Montage du Token​

Le token est automatiquement monté dans le Pod à /var/run/secrets/kubernetes.io/serviceaccount/:

# Dans le Pod
cat /var/run/secrets/kubernetes.io/serviceaccount/token
cat /var/run/secrets/kubernetes.io/serviceaccount/namespace
cat /var/run/secrets/kubernetes.io/serviceaccount/ca.crt

Permissions RBAC​

Lier un Service Account à un Role​

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: app-role-binding
  namespace: default
subjects:
- kind: ServiceAccount
  name: my-app-sa
  namespace: default
roleRef:
  kind: Role
  name: app-role
  apiGroup: rbac.authorization.k8s.io

Exemple Complet​

Étape 1: Créer le Service Account

apiVersion: v1
kind: ServiceAccount
metadata:
  name: pod-reader-sa
  namespace: default

Étape 2: Créer le Role

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "list", "watch"]

Étape 3: Créer le RoleBinding

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: pod-reader-binding
  namespace: default
subjects:
- kind: ServiceAccount
  name: pod-reader-sa
  namespace: default
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Étape 4: Utiliser dans un Pod

apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  serviceAccountName: pod-reader-sa
  containers:
  - name: app
    image: my-app:1.0

Résultat: Le Pod peut lire les Pods dans le namespace default.

Accès à l'API Kubernetes​

Utiliser le Token dans l'Application​

import os
import requests

# Lire le token
with open('/var/run/secrets/kubernetes.io/serviceaccount/token', 'r') as f:
    token = f.read().strip()

# Lire le namespace
with open('/var/run/secrets/kubernetes.io/serviceaccount/namespace', 'r') as f:
    namespace = f.read().strip()

# Appel API
api_url = f"https://kubernetes.default.svc/api/v1/namespaces/{namespace}/pods"
headers = {
    'Authorization': f'Bearer {token}',
    'Content-Type': 'application/json'
}

response = requests.get(api_url, headers=headers, verify='/var/run/secrets/kubernetes.io/serviceaccount/ca.crt')
print(response.json())

Image Pull Secrets​

Les Service Accounts peuvent avoir des imagePullSecrets pour accéder aux registres Docker privés:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: private-registry-sa
  namespace: default
imagePullSecrets:
- name: regcred

Résultat: Tous les Pods utilisant ce Service Account peuvent pull des images du registre privé.

Service Account par Défaut​

Désactiver le Montage Automatique​

apiVersion: v1
kind: ServiceAccount
metadata:
  name: no-token-sa
  namespace: default
automountServiceAccountToken: false

Résultat: Le token n'est pas monté dans les Pods utilisant ce Service Account.

Au Niveau du Pod​

apiVersion: v1
kind: Pod
metadata:
  name: no-token-pod
spec:
  serviceAccountName: my-app-sa
  automountServiceAccountToken: false
  containers:
  - name: app
    image: my-app:1.0

Bonnes Pratiques​

1. Service Account par Application​

Créer un Service Account dédié pour chaque application.

2. Principe du Moindre Privilège​

Donner seulement les permissions nécessaires via RBAC.

3. Pas de Service Account par Défaut​

Éviter d'utiliser le Service Account default en production.

4. Désactiver le Token si Non Nécessaire​

Utiliser automountServiceAccountToken: false si l'application n'a pas besoin d'accéder à l'API.

5. Rotation des Tokens​

Les tokens sont automatiquement renouvelés par Kubernetes.

Commandes Utiles​

Gestion​

# Créer un Service Account
kubectl create serviceaccount my-app-sa

# Voir les Service Accounts
kubectl get serviceaccounts
kubectl get sa

# Détails
kubectl describe serviceaccount my-app-sa

# Voir les secrets associés
kubectl get secrets | grep my-app-sa

Utilisation​

# Créer un Pod avec un Service Account
kubectl run my-pod --image=my-app:1.0 --serviceaccount=my-app-sa

# Voir le token dans un Pod
kubectl exec my-pod -- cat /var/run/secrets/kubernetes.io/serviceaccount/token

Résumé​

Dans ce chapitre, vous avez appris:

Service Account: Identité pour les Pods dans Kubernetes
Création: Ressource Kubernetes simple
Utilisation: Via serviceAccountName dans les Pods
Tokens: Créés automatiquement et montés dans /var/run/secrets/kubernetes.io/serviceaccount/
RBAC: Lier des Service Accounts à des Roles pour les permissions
Accès API: Utiliser le token pour appeler l'API Kubernetes
Image Pull Secrets: Pour accéder aux registres privés
Bonnes pratiques: Service Account par application, moindre privilège

Prochaines Étapes​

Chapitre 9.3: Network Policies
Chapitre 9.4: Pod Security Standards
Lab 9.2: Service Accounts et Permissions

Chapitre créé le: Décembre 2024