Codez votre Cloud et Kubernetes avec Crossplane et IaC

Tutoriels

Kubernetes MySQL

À mesure que les organisations adoptent Kubernetes pour des applications cloud-native, la gestion efficace de l’infrastructure devient un défi. Les outils traditionnels d’Infrastructure as Code (IaC) comme Terraform, Pulumi et d’autres offrent des configurations déclaratives mais manquent d’une intégration fluide dans les workflows natifs de Kubernetes.

Crossplane comble efficacement le fossé entre Kubernetes et l’infrastructure cloud dans cette situation. Dans ce blog, nous explorerons comment Crossplane permet l’IaC pour Kubernetes et au-delà.

Qu’est-ce que Crossplane ?

Crossplane est un add-on Kubernetes open-source qui vous permet de provisionner et de gérer l’infrastructure cloud en utilisant les Définitions de Ressources Personnalisées (CRD) et l’API Kubernetes. Contrairement aux outils IaC traditionnels qui nécessitent une exécution externe, comme les scripts Terraform exécutés en externe, Crossplane intègre la gestion de l’infrastructure dans Kubernetes. Cela le rend véritablement déclaratif et compatible avec GitOps.

Cas d’utilisation : Terraform vs. Crossplane

Quand utiliser Terraform ?

Idéal pour gérer l’infrastructure en dehors de Kubernetes
Parfait pour les déploiements multi-cloud traditionnels et les VM
Écosystème solide avec de nombreux modules et fournisseurs
Fonctionne bien avec des outils comme Ansible, Packer et Vault pour l’automatisation

Quand utiliser Crossplane?

Idéal pour les environnements centrés sur Kubernetes
Idéal pour les flux de travail GitOps (ArgoCD, Flux)
Permet la provision en libre-service via les CRD Kubernetes
Bon pour le contrôle Kubernetes multi-cloud (gestion des services cloud via l’API K8s)

Commencer avec Crossplane

Pour cet exemple, nous utiliserons un minikube. Mais les mêmes étapes peuvent être appliquées à n’importe quel Kubernetes.

Étape 1: Déployer MySQL dans Kubernetes

1. Déployer MySQL en tant que Deployment avec un Service pour la configuration en utilisant Crossplane. Vous pouvez également utiliser MySQL déployé depuis un autre emplacement.

2. Définir un mysql-deployment.yaml, qui crée le secret, le déploiement et le service requis pour exécuter MySQL.

YAML

apiVersion: v1

kind: Secret

metadata:

  name: mysql-root-password

type: Opaque

data:

  password: cGFzc3dvcmQ=  # Base64 encoded "password"

---

apiVersion: v1

kind: Service

metadata:

  name: mysql-service

spec:

  selector:

    app: mysql

  ports:

    - protocol: TCP

      port: 3306

      targetPort: 3306

---

apiVersion: apps/v1

kind: Deployment

metadata:

  name: mysql

spec:

  selector:

    matchLabels:

      app: mysql

  strategy:

    type: Recreate

  template:

    metadata:

      labels:

        app: mysql

    spec:

      containers:

        - image: mysql:8.0

          name: mysql

          env:

            - name: MYSQL_ROOT_PASSWORD

              valueFrom:

                secretKeyRef:

                  name: mysql-root-password

                  key: password

          ports:

            - containerPort: 3306

              name: mysql

​

3. Appliquer le YAML en utilisant la commande kubectl apply -f mysql-deployment.yaml.

4. Vérifier que les pods sont en cours d’exécution en utilisant la commande kubectl get pods.

5. Vérifier la connexion MySQL en démarrant un pod SQL temporaire pour vérifier le déploiement MySQL. Créez le client en utilisant la commande kubectl run mysql-client --image=mysql:8.0 -it --rm -- bash.

6. Se connecter à MySQL à l’intérieur du pod en utilisant la commande mysql -h mysql-service.default.svc.cluster.local -uroot -ppassword.

Étape 2: Installer Crossplane sur Kubernetes

1. Installer Crossplane en utilisant Helm:

Shell

kubectl create namespace crossplane-system

helm repo add crossplane-stable https://charts.crossplane.io/stable

helm repo update

helm install crossplane crossplane-stable/crossplane --namespace crossplane-system

Note: Crossplane prend quelques minutes pour démarrer.

2. Vérifier l’installation de Crossplane en utilisant la commande kubectl get pods -n crossplane-system.

Étape 3: Installer le Fournisseur Crossplane pour SQL

1. Définir un fournisseur MySQL en utilisant le contenu YAML ci-dessous.

YAML

apiVersion: pkg.crossplane.io/v1

kind: Provider

metadata:

  name: provider-sql

spec:

  package: xpkg.upbound.io/crossplane-contrib/provider-sql:v0.9.0

2. Créer le fournisseur en utilisant la commande kubectl apply -f provider.yaml.

3. Vérifier le fournisseur en utilisant les commandes suivantes: kubectl get pods -n crossplane-system et kubectl get providers.

Note: Les fournisseurs SQL prennent quelques minutes pour démarrer.

Étape 4: Configurer le Fournisseur MySQL Crossplane

La configuration du fournisseur indique à Crossplane comment s’authentifier avec MySQL. Définir les secrets à créer pour l’utilisation du fournisseur. Mettre à jour le stringData en conséquence dans le YAML ci-dessous. Appliquer le YAML en utilisant kubectl apply -f mysql-secret.yaml.

YAML

apiVersion: v1

kind: Secret

metadata:

  name: mysql-conn-secret

  namespace: default

type: Opaque

stringData:

  credentials: "root:password@tcp(mysql-service.default.svc.cluster.local:3306)"

  username: "root"

  password: "password"

  endpoint: "mysql-service.default.svc.cluster.local"

  port: "3306"

Appliquer la configuration du fournisseur ci-dessous pour Crossplane, qui utilise les secrets ci-dessus. L’appliquer en utilisant la commande kubectl apply -f providerconfig.yaml.

YAML

apiVersion: mysql.sql.crossplane.io/v1alpha1

kind: ProviderConfig

metadata:

  name: mysql-provider

spec:

  credentials:

    source: MySQLConnectionSecret

    connectionSecretRef:

      name: mysql-conn-secret

      namespace: default

​

Vérifier la création de la configuration du fournisseur en utilisant les commandes — kubectl get providerconfigs.mysql.sql.crossplane.io et kubectl get crds | grep providerconfig.

Étape 5. Créer une Base de Données MySQL en Utilisant Crossplane

Maintenant, utilisez Crossplane pour provisionner une nouvelle base de données. Utilisez le YAML ci-dessous et appliquez-le en utilisant kubectl apply -f mysqlinstance.yaml.

YAML

apiVersion: mysql.sql.crossplane.io/v1alpha1

kind: Database

metadata:

  name: my-database

spec:

  providerConfigRef:

    name: mysql-provider

  forProvider:

    binlog: true  

  writeConnectionSecretToRef:

    name: db-conn

    namespace: default

Étape 6: Vérifier la Création de la Base de Données

Vérifiez la création de la base de données en utilisant la commande kubectl get database.mysql.sql.crossplane.io/my-database.

Utilisez les mêmes étapes de vérification mentionnées à l’étape 1 pour vous connecter à MySQL et vérifier la création de la base de données.

Avec les étapes ci-dessus, vous avez installé Crossplane, configuré le fournisseur MySQL et utilisé Crossplane pour provisionner une base de données.

Est-ce que Terraform et Crossplane Peuvent Fonctionner Ensemble?

Terraform et Crossplane peuvent être utilisés ensemble pour de nombreux scénarios.

Scénario 1

Dans un scénario complet d’IaC, Terraform peut être utilisé pour amorcer des clusters Kubernetes, puis Crossplane peut être utilisé pour gérer les ressources cloud depuis Kubernetes. Terraform peut également déployer Crossplane lui-même. Cet exemple de flux de travail hybride peut être

Terraform provisionne le cluster Kubernetes sur n’importe quel fournisseur cloud.
Crossplane gère les services cloud (bases de données, stockage et réseau) en utilisant les CRD Kubernetes.

Scénario 2

Crossplane prend également en charge un fournisseur Terraform, qui peut être utilisé pour exécuter des scripts Terraform dans le cadre du modèle IaC de Crossplane. L’exécution d’un fournisseur Terraform pour Crossplane peut être utile dans plusieurs scénarios où les fournisseurs natifs de Crossplane ne prennent pas encore en charge certaines ressources ou fonctionnalités cloud. Voici les raisons d’exécuter un fournisseur Terraform pour Crossplane :

Terraform dispose d’un vaste écosystème de fournisseurs, soutenant de nombreux services cloud pour lesquels Crossplane n’a peut-être pas encore de fournisseurs natifs.
Lorsque qu’une organisation utilise déjà Terraform pour la gestion de l’infrastructure, il n’est pas nécessaire de tout réécrire en CRDs Crossplane.
Crossplane prend en charge la gestion multi-cloud, mais ses fournisseurs natifs peuvent ne pas couvrir toutes les intégrations sur site ou SaaS.
Pour les organisations cherchant à passer progressivement de Terraform à Crossplane, l’utilisation de fournisseurs Terraform au sein de Crossplane peut servir de solution hybride avant une migration complète.
L’exécution de Terraform au sein de Crossplane place Terraform sous le modèle déclaratif GitOps de Kubernetes.

Étapes pour créer une base de données Cloudant sur IBM Cloud en utilisant Crossplane

Étape 1. Définir le fournisseur Terraform.

YAML

apiVersion: pkg.crossplane.io/v1

kind: Provider

metadata:

  name: provider-terraform

spec:

  package: xpkg.upbound.io/upbound/provider-terraform:v0.19.0

​

Étape 2. Configurer le fournisseur.

YAML

apiVersion: tf.upbound.io/v1beta1

kind: ProviderConfig

metadata:

  name: terraform-provider-ibm

spec: {}

​

Étape 3. Provisionner une base de données Cloudant sur IBM Cloud en utilisant des scripts Terraform dans le cadre de Crossplane.

YAML

apiVersion: tf.upbound.io/v1beta1

kind: Workspace

metadata:

  name: ibm-cloudant-db

spec:

  providerConfigRef:

    name: terraform-provider-ibm

  writeConnectionSecretToRef:

    name: ibmcloud-terraform-secret

    namespace: crossplane-system

  forProvider:

    source: Inline

    module: |

      terraform {

        required_providers {

          ibm = {

            source  = "IBM-Cloud/ibm"

          }

        }

        backend "kubernetes" {

          secret_suffix = "ibmcloud-terraform-secret"

          namespace     = "crossplane-system"

        }

      }

​

      provider "ibm" {

        ibmcloud_api_key = var.ibmcloud_api_key

      }

​

      resource "ibm_cloudant" "cloudant_instance" {

        name     = "crossplanecloudant"

        location = "us-south"

        plan     = "lite"

      }

​

      variable "ibmcloud_api_key" {

        type = string

      }

​

    vars:

      - key: ibmcloud_api_key

        value: "<Your IBM Cloud API Key>"

​

Cela provisionne une base de données Cloudant nommée crossplanecloudant sur IBM Cloud.

Comment Crossplane s’inscrit dans l’ingénierie des plateformes

L’ingénierie de plateforme se concentre sur la construction et la maintenance des plateformes de développeurs internes (IDP) qui simplifient la gestion de l’infrastructure et le déploiement d’applications. Crossplane joue un rôle important en permettant une approche native de Kubernetes.

Crossplane garantit la provision déclarative, en libre-service et pilotée par des politiques des ressources cloud. Des fonctionnalités de Crossplane telles que l’infrastructure déclarative avec des APIs K8s, des abstractions personnalisées pour l’infra et les apps, des garde-fous de sécurité et de conformité, des déploiements versionnés et automatisés, et une correction continue des dérives aident l’ingénierie de plateforme.

Conclusion

Crossplane transforme la manière dont nous gérons l’infrastructure cloud en intégrant l’IaC dans l’écosystème Kubernetes. Les APIs de Kubernetes permettent une approche vraiment déclarative et orientée GitOps pour la provision et la gestion des ressources cloud. Si vous utilisez déjà Kubernetes et cherchez à moderniser votre stratégie IaC, Crossplane vaut vraiment la peine d’être exploré.

Source:
https://dzone.com/articles/codify-cloud-kubernetes-crossplane-iac