Création d'un client Kubernetes pour Google Kubernetes Engine (GKE) en Python

Cet article de blog présente une méthode efficace pour créer un client Kubernetes pour GKE en Python. En tirant parti des bibliothèques google-cloud-container, google-auth et kubernetes, vous pouvez utiliser le même code pour interagir avec l'API Kubernetes, que votre application s'exécute localement ou sur Google Cloud. Cette flexibilité provient de l'utilisation des Application Default Credentials (ADC) pour authentifier et construire dynamiquement les requêtes nécessaires aux interactions de l'API Kubernetes, éliminant ainsi le besoin d'outils ou de fichiers de configuration supplémentaires tels que kubeconfig.

Lors d'une exécution locale, une approche courante consiste à utiliser la commande gcloud containers clusters get-credentials pour générer un fichier kubeconfig et interagir avec l'API Kubernetes à l'aide de kubectl. Bien que ce flux de travail soit naturel et efficace pour les configurations locales, il devient moins pratique dans des environnements tels que Cloud Run ou d'autres services Google Cloud.

Avec ADC, vous pouvez rationaliser l'accès à l'API Kubernetes pour les clusters GKE en configurant dynamiquement le client Kubernetes. Cette approche garantit un moyen cohérent et efficace de se connecter à votre cluster sans avoir à gérer des fichiers de configuration externes ou à installer des outils supplémentaires.

---

Conditions préalables

1. Authentification avec Google Cloud

Si vous exécutez le code localement, authentifiez-vous simplement à l'aide de la commande suivante :

gcloud auth application-default login

Cela utilisera les informations d'identification de votre compte utilisateur comme informations d'identification par défaut de l'application (ADC).

Si vous exécutez le code sur des services Google Cloud tels que Cloud Run, vous n'avez pas besoin de gérer l'authentification manuellement. Assurez-vous simplement que le service dispose d'un compte de service correctement configuré associé aux autorisations nécessaires pour accéder au cluster GKE.

---

2. Rassemblez les détails de votre cluster

Avant d'exécuter le script, assurez-vous d'avoir les détails suivants :

• ID du projet Google Cloud : ID du projet dans lequel votre cluster GKE est hébergé.
• Emplacement du cluster : la région ou la zone où se trouve votre cluster (par exemple, us-central1-a).
• Nom du cluster : Le nom du cluster Kubernetes auquel vous souhaitez vous connecter.

---

Le scénario

Vous trouverez ci-dessous la fonction Python qui configure un client Kubernetes pour un cluster GKE.

gcloud auth application-default login

---

Comment ça marche

1. Connexion au cluster GKE

La fonction get_k8s_client commence par récupérer les détails du cluster depuis GKE à l'aide de la bibliothèque google-cloud-container. Cette bibliothèque interagit avec le service GKE, vous permettant de récupérer des informations telles que le point de terminaison de l'API et l'autorité de certification (CA) du cluster. Ces détails sont essentiels pour configurer le client Kubernetes.

from google.cloud import container_v1
import google.auth
import google.auth.transport.requests
from kubernetes import client as kubernetes_client
from tempfile import NamedTemporaryFile
import base64
import yaml

def get_k8s_client(project_id: str, location: str, cluster_id: str) -> kubernetes_client.CoreV1Api:
    """
    Fetches a Kubernetes client for the specified GCP project, location, and cluster ID.

    Args:
        project_id (str): Google Cloud Project ID
        location (str): Location of the cluster (e.g., "us-central1-a")
        cluster_id (str): Name of the Kubernetes cluster

    Returns:
        kubernetes_client.CoreV1Api: Kubernetes CoreV1 API client
    """

    # Retrieve cluster information
    gke_cluster = container_v1.ClusterManagerClient().get_cluster(request={
        "name": f"projects/{project_id}/locations/{location}/clusters/{cluster_id}"
    })

    # Obtain Google authentication credentials
    creds, _ = google.auth.default()
    auth_req = google.auth.transport.requests.Request()
    # Refresh the token
    creds.refresh(auth_req)

    # Initialize the Kubernetes client configuration object
    configuration = kubernetes_client.Configuration()
    # Set the cluster endpoint
    configuration.host = f'https://{gke_cluster.endpoint}'

    # Write the cluster CA certificate to a temporary file
    with NamedTemporaryFile(delete=False) as ca_cert:
        ca_cert.write(base64.b64decode(gke_cluster.master_auth.cluster_ca_certificate))
        configuration.ssl_ca_cert = ca_cert.name

    # Set the authentication token
    configuration.api_key_prefix['authorization'] = 'Bearer'
    configuration.api_key['authorization'] = creds.token

    # Create and return the Kubernetes CoreV1 API client
    return kubernetes_client.CoreV1Api(kubernetes_client.ApiClient(configuration))


def main():
    project_id = "your-project-id"  # Google Cloud Project ID
    location = "your-cluster-location"  # Cluster region (e.g., "us-central1-a")
    cluster_id = "your-cluster-id"  # Cluster name

    # Retrieve the Kubernetes client
    core_v1_api = get_k8s_client(project_id, location, cluster_id)

    # Fetch the kube-system Namespace
    namespace = core_v1_api.read_namespace(name="kube-system")

    # Output the Namespace resource in YAML format
    yaml_output = yaml.dump(namespace.to_dict(), default_flow_style=False)
    print(yaml_output)

if __name__ == "__main__":
    main()

Il est important de noter que la bibliothèque google-cloud-container est conçue pour interagir avec GKE en tant que service, et non directement avec les API Kubernetes. Par exemple, même si vous pouvez utiliser cette bibliothèque pour récupérer des informations sur le cluster, mettre à niveau des clusters ou configurer des politiques de maintenance (comme ce que vous pouvez faire avec la commande gcloud containers clusters), vous ne pouvez pas l'utiliser pour obtenir directement un client API Kubernetes. Cette distinction explique pourquoi la fonction construit un client Kubernetes séparément après avoir récupéré les détails du cluster nécessaires auprès de GKE.

---

2. Authentification avec Google Cloud

Pour interagir avec les API GKE et Kubernetes, la fonction utilise les informations d'identification par défaut de l'application (ADC) de Google Cloud pour s'authentifier. Voici comment fonctionne chaque étape du processus d'authentification :

google.auth.default()

Cette fonction récupère l'ADC pour l'environnement dans lequel le code s'exécute. Selon le contexte, cela peut revenir :

• Identifiants du compte utilisateur (par exemple, à partir de la connexion par défaut de l'application d'authentification gcloud dans une configuration de développement local).
• Identifiants du compte de service (par exemple, lors de l'exécution dans un environnement Google Cloud tel que Cloud Run).

Il renvoie également l'ID du projet associé s'il est disponible, bien que dans ce cas, seules les informations d'identification soient utilisées.

google.auth.transport.requests.Request()

Cela crée un objet de requête HTTP pour gérer les requêtes réseau liées à l'authentification. Il utilise la bibliothèque de requêtes de Python en interne et fournit un moyen standardisé d'actualiser les informations d'identification ou de demander des jetons d'accès.

creds.refresh(auth_req)

Lorsque l'ADC est récupéré à l'aide de google.auth.default(), l'objet d'informations d'identification n'inclut pas initialement de jeton d'accès (au moins dans un environnement local). La méthode rafraîchir() obtient explicitement un jeton d'accès et l'attache à l'objet d'informations d'identification, lui permettant d'authentifier les requêtes API.

Le code suivant montre comment vérifier ce comportement :

gke_cluster = container_v1.ClusterManagerClient().get_cluster(request={
    "name": f"projects/{project_id}/locations/{location}/clusters/{cluster_id}"
})

exemple de sortie :

# Obtain Google authentication credentials
creds, _ = google.auth.default()
auth_req = google.auth.transport.requests.Request()

# Inspect credentials before refreshing
print(f"Access Token (before refresh()): {creds.token}")
print(f"Token Expiry (before refresh()): {creds.expiry}")

# Refresh the token
creds.refresh(auth_req)

# Inspect credentials after refreshing
print(f"Access Token (after): {creds.token}")
print(f"Token Expiry (after): {creds.expiry}")

Avant d'appeler rafraîchir(), l'attribut du jeton est Aucun. Une fois rafraîchissement() invoqué, les informations d'identification sont renseignées avec un jeton d'accès valide et son heure d'expiration.

---

3. Configuration du client Kubernetes

Le client Kubernetes est configuré à l'aide du point de terminaison API du cluster, d'un fichier temporaire pour le certificat CA et du jeton Bearer actualisé. Cela garantit que le client peut s'authentifier et communiquer en toute sécurité avec le cluster.

gcloud auth application-default login

Le certificat CA est stocké temporairement et référencé par le client pour une communication SSL sécurisée. Avec ces paramètres, le client Kubernetes est entièrement configuré et prêt à interagir avec le cluster.

---

Exemple de sortie

Voici un exemple de sortie YAML pour l'espace de noms kube-system :

from google.cloud import container_v1
import google.auth
import google.auth.transport.requests
from kubernetes import client as kubernetes_client
from tempfile import NamedTemporaryFile
import base64
import yaml

def get_k8s_client(project_id: str, location: str, cluster_id: str) -> kubernetes_client.CoreV1Api:
    """
    Fetches a Kubernetes client for the specified GCP project, location, and cluster ID.

    Args:
        project_id (str): Google Cloud Project ID
        location (str): Location of the cluster (e.g., "us-central1-a")
        cluster_id (str): Name of the Kubernetes cluster

    Returns:
        kubernetes_client.CoreV1Api: Kubernetes CoreV1 API client
    """

    # Retrieve cluster information
    gke_cluster = container_v1.ClusterManagerClient().get_cluster(request={
        "name": f"projects/{project_id}/locations/{location}/clusters/{cluster_id}"
    })

    # Obtain Google authentication credentials
    creds, _ = google.auth.default()
    auth_req = google.auth.transport.requests.Request()
    # Refresh the token
    creds.refresh(auth_req)

    # Initialize the Kubernetes client configuration object
    configuration = kubernetes_client.Configuration()
    # Set the cluster endpoint
    configuration.host = f'https://{gke_cluster.endpoint}'

    # Write the cluster CA certificate to a temporary file
    with NamedTemporaryFile(delete=False) as ca_cert:
        ca_cert.write(base64.b64decode(gke_cluster.master_auth.cluster_ca_certificate))
        configuration.ssl_ca_cert = ca_cert.name

    # Set the authentication token
    configuration.api_key_prefix['authorization'] = 'Bearer'
    configuration.api_key['authorization'] = creds.token

    # Create and return the Kubernetes CoreV1 API client
    return kubernetes_client.CoreV1Api(kubernetes_client.ApiClient(configuration))


def main():
    project_id = "your-project-id"  # Google Cloud Project ID
    location = "your-cluster-location"  # Cluster region (e.g., "us-central1-a")
    cluster_id = "your-cluster-id"  # Cluster name

    # Retrieve the Kubernetes client
    core_v1_api = get_k8s_client(project_id, location, cluster_id)

    # Fetch the kube-system Namespace
    namespace = core_v1_api.read_namespace(name="kube-system")

    # Output the Namespace resource in YAML format
    yaml_output = yaml.dump(namespace.to_dict(), default_flow_style=False)
    print(yaml_output)

if __name__ == "__main__":
    main()

---

Conclusion

Cette approche met en évidence la portabilité de l'utilisation du même code pour interagir avec l'API Kubernetes, qu'elle soit exécutée localement ou sur un service Google Cloud comme Cloud Run. En tirant parti des informations d'identification par défaut de l'application (ADC), nous avons démontré une méthode flexible pour générer dynamiquement un client API Kubernetes sans recourir à des fichiers de configuration pré-générés ou à des outils externes. Cela facilite la création d'applications capables de s'adapter de manière transparente à différents environnements, simplifiant ainsi les flux de travail de développement et de déploiement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!