Kodifizieren Sie Ihre Cloud und Kubernetes mit Crossplane und IaC

Tutorials

Kubernetes MySQL

Da Organisationen Kubernetes für cloud-native Anwendungen nutzen, wird das effiziente Management der Infrastruktur herausfordernd. Traditionelle Infrastructure as Code (IaC) Werkzeuge wie Terraform, Pulumi und andere bieten deklarative Konfigurationen, aber es fehlt an nahtloser Integration in die Kubernetes-nativen Workflows.

Crossplane überbrückt in dieser Situation effektiv die Lücke zwischen Kubernetes und Cloud-Infrastruktur. In diesem Blog werden wir untersuchen, wie Crossplane IaC für Kubernetes und darüber hinaus ermöglicht.

Was ist Crossplane?

Crossplane ist ein Open-Source-Kubernetes-Add-On, das es Ihnen ermöglicht, Cloud-Infrastruktur mithilfe von Kubernetes Custom Resource Definitions (CRDs) und der Kubernetes API bereitzustellen und zu verwalten. Im Gegensatz zu traditionellen IaC-Tools, die externe Ausführung erfordern, wie zum Beispiel das Ausführen von Terraform-Skripten extern, bindet Crossplane das Infrastrukturmanagement in Kubernetes ein. Dies macht es wirklich deklarativ und GitOps-freundlich.

Anwendungsfälle: Terraform vs. Crossplane

Wann sollten Sie Terraform verwenden?

Am besten geeignet für das Management von Infrastruktur außerhalb von Kubernetes
Ideal für traditionelle Multi-Cloud-Deployments und VMs
Starkes Ökosystem mit umfangreichen Modulen und Anbietern
Funktioniert gut mit Werkzeugen wie Ansible, Packer und Vault zur Automatisierung

Wann sollte man Crossplane verwenden?

Am besten für Kubernetes-zentrierte Umgebungen
Ideal für GitOps-Workflows (ArgoCD, Flux)
Ermöglicht Self-Service-Bereitstellungen über Kubernetes CRDs
Gut für Multi-Cloud Kubernetes-Kontrolle (Verwaltung von Cloud-Diensten über die K8s API)

Erste Schritte mit Crossplane

Für dieses Beispiel verwenden wir ein minikube. Die gleichen Schritte können jedoch auf jedes Kubernetes angewendet werden.

Schritt 1: MySQL in Kubernetes bereitstellen

1. Stellen Sie MySQL als Deployment mit einem Service bereit, um es mit Crossplane zu konfigurieren. Sie können auch MySQL verwenden, das von einem anderen Ort bereitgestellt wird.

2. Definieren Sie eine mysql-deployment.yaml, die das erforderliche Secret, Deployment und den Service erstellt, um MySQL auszuführen.

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. Wenden Sie die YAML mit dem Befehl kubectl apply -f mysql-deployment.yaml an.

4. Überprüfen Sie, ob die Pods aktiv sind, indem Sie den Befehl kubectl get pods verwenden.

5. Überprüfen Sie die MySQL-Verbindung, indem Sie einen temporären SQL-Pod starten, um das MySQL-Deployment zu überprüfen. Erstellen Sie den Client mit dem Befehl kubectl run mysql-client --image=mysql:8.0 -it --rm -- bash.

6. Stellen Sie eine Verbindung zu MySQL im Pod her, indem Sie den Befehl mysql -h mysql-service.default.svc.cluster.local -uroot -ppassword verwenden.

Schritt 2: Crossplane auf Kubernetes installieren

1. Installieren Sie Crossplane mit 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

Hinweis: Crossplane benötigt einige Minuten, um hochzufahren.

2. Überprüfen Sie die Crossplane-Installation mit dem Befehl kubectl get pods -n crossplane-system.

Schritt 3: Den Crossplane Provider für SQL installieren

1. Definieren Sie einen MySQL-Provider mit dem folgenden YAML-Inhalt.

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. Erstellen Sie den Provider mit dem Befehl kubectl apply -f provider.yaml.

3. Überprüfen Sie den Provider mit den folgenden Befehlen: kubectl get pods -n crossplane-system und kubectl get providers.

Hinweis: SQL-Provider benötigen einige Minuten, um hochzufahren.

Schritt 4: Den Crossplane MySQL Provider konfigurieren

Die Anbieter-Konfiguration weist Crossplane an, wie es sich bei MySQL authentifizieren soll. Definieren Sie die Geheimnisse, die für die Nutzung des Providers erstellt werden sollen. Aktualisieren Sie das stringData entsprechend im folgenden YAML. Wenden Sie das YAML mit kubectl apply -f mysql-secret.yaml an.

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"

Wenden Sie die folgende Provider-Konfiguration für Crossplane an, die die oben genannten Geheimnisse verwendet. Wenden Sie es mit dem Befehl kubectl apply -f providerconfig.yaml an.

YAML

apiVersion: mysql.sql.crossplane.io/v1alpha1

kind: ProviderConfig

metadata:

  name: mysql-provider

spec:

  credentials:

    source: MySQLConnectionSecret

    connectionSecretRef:

      name: mysql-conn-secret

      namespace: default

​

Überprüfen Sie die Erstellung der Provider-Konfiguration mit den Befehlen — kubectl get providerconfigs.mysql.sql.crossplane.io und kubectl get crds | grep providerconfig.

Schritt 5. Erstellen Sie eine MySQL-Datenbank mit Crossplane

Verwenden Sie jetzt Crossplane, um eine neue Datenbank bereitzustellen. Verwenden Sie das folgende YAML und wenden Sie es mit kubectl apply -f mysqlinstance.yaml an.

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

Schritt 6: Verifizieren der Datenbankerstellung

Verifizieren Sie die Datenbankerstellung mit dem Befehl kubectl get database.mysql.sql.crossplane.io/my-database.

Verwenden Sie dieselben Verifizierungsschritte, die im Schritt 1 erwähnt wurden, um sich mit MySQL zu verbinden und die Erstellung der Datenbank zu überprüfen.

Mit den obigen Schritten haben Sie Crossplane installiert, den MySQL-Anbieter konfiguriert und Crossplane verwendet, um eine Datenbank bereitzustellen.

Können Terraform und Crossplane zusammenarbeiten?

Terraform und Crossplane können für viele Szenarien zusammen verwendet werden.

Szenario 1

In einem kompletten IaC-Szenario kann Terraform verwendet werden, um Kubernetes-Cluster zu initialisieren, und dann kann Crossplane verwendet werden, um Cloud-Ressourcen innerhalb von Kubernetes zu verwalten. Terraform kann auch Crossplane selbst bereitstellen. Dieses Beispiel für einen hybriden Workflow kann sein

Terraform bereitstellt den Kubernetes-Cluster in jedem Cloud-Anbieter.
Crossplane verwaltet Cloud-Dienste (Datenbanken, Speicher und Netzwerke) mithilfe von Kubernetes CRDs.

Szenario 2

Crossplane unterstützt auch einen Terraform-Provider, der verwendet werden kann, um Terraform-Skripte als Teil des IaC-Modells von Crossplane auszuführen. Das Ausführen eines Terraform-Providers für Crossplane kann in mehreren Szenarien nützlich sein, in denen die nativen Provider von Crossplane noch bestimmte Cloud-Ressourcen oder -Funktionen nicht unterstützen. Folgendes sind die Gründe, einen Terraform-Provider für Crossplane auszuführen:

Terraform hat ein umfangreiches Ökosystem von Providern, die viele Cloud-Dienste unterstützen, für die Crossplane möglicherweise noch keine nativen Provider hat.
Wenn eine Organisation bereits Terraform für das Infrastrukturmanagement verwendet, gibt es keine Notwendigkeit, alles in Crossplane-CRDs neu zu schreiben.
Crossplane unterstützt das Multi-Cloud-Management, aber seine nativen Provider decken möglicherweise nicht jede On-Premise- oder SaaS-Integration ab.
Für Organisationen, die schrittweise von Terraform zu Crossplane übergehen möchten, kann die Verwendung von Terraform-Providern innerhalb von Crossplane als hybride Lösung vor der vollständigen Migration fungieren.
Das Ausführen von Terraform innerhalb von Crossplane bringt Terraform unter das deklarative GitOps-Modell von Kubernetes.

Schritte zur Erstellung einer IBM Cloud Cloudant DB mit Crossplane

Schritt 1. Definieren Sie den Terraform-Provider.

YAML

apiVersion: pkg.crossplane.io/v1

kind: Provider

metadata:

  name: provider-terraform

spec:

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

​

Schritt 2. Konfigurieren Sie den Provider.

YAML

apiVersion: tf.upbound.io/v1beta1

kind: ProviderConfig

metadata:

  name: terraform-provider-ibm

spec: {}

​

Schritt 3. Stellen Sie eine Cloudant DB in der IBM Cloud bereit, indem Sie Terraform-Skripte als Teil des Crossplane verwenden.

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

​

Dies stellt eine Cloudant DB mit dem Namen crossplanecloudant in der IBM Cloud bereit.

Wie Crossplane in die Plattformtechnik passt

Plattformtechnik konzentriert sich auf den Aufbau und die Pflege von internen Entwicklerplattformen (IDPs), die die Infrastrukturverwaltung und Anwendungsbereitstellung vereinfachen. Crossplane spielt dabei eine wichtige Rolle, indem es einen Kubernetes-nativen Ansatz ermöglicht.

Crossplane gewährleistet deklarative, self-service- und richtliniengesteuerte Bereitstellung von Cloud-Ressourcen. Crossplane-Funktionen wie deklarative Infrastruktur mit K8s-APIs, benutzerdefinierte Abstraktionen für Infrastruktur und Anwendungen, Sicherheits- und Compliance-Richtlinien, versionskontrollierte und automatisierte Bereitstellungen sowie kontinuierliche Abweichungskorrekturen helfen bei der Plattformtechnik.

Fazit

Crossplane verändert die Art und Weise, wie wir Cloud-Infrastruktur verwalten, indem es IaC in das Kubernetes-Ökosystem integriert. Kubernetes-APIs ermöglichen einen wirklich deklarativen und GitOps-getriebenen Ansatz zur Bereitstellung und Verwaltung von Cloud-Ressourcen. Wenn Sie bereits Kubernetes verwenden und Ihre IaC-Strategie modernisieren möchten, lohnt es sich auf jeden Fall, Crossplane zu erkunden.

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