Codeer uw cloud en Kubernetes met Crossplane en IaC

Kubernetes MySQL

Terwijl organisaties Kubernetes omarmen voor cloud-native applicaties, wordt het efficiënt beheren van de infrastructuur uitdagend. Traditionele Infrastructure as Code (IaC) tools zoals Terraform, Pulumi en anderen bieden declaratieve configuraties maar missen naadloze integratie in de Kubernetes-native workflows.

Crossplane overbrugt effectief de kloof tussen Kubernetes en cloud-infrastructuur in deze situatie. In deze blog zullen we verkennen hoe Crossplane IaC mogelijk maakt voor Kubernetes en verder.

Wat Is Crossplane?

Crossplane is een open-source Kubernetes add-on die je in staat stelt om cloud-infrastructuur te voorzien en beheren met behulp van Kubernetes Custom Resource Definitions (CRDs) en de Kubernetes API. In tegenstelling tot traditionele IaC-tools die externe uitvoering vereisen, zoals het extern uitvoeren van Terraform-scripts, integreert Crossplane het infrastructuurbeheer in Kubernetes. Dit maakt het echt declaratief en GitOps-vriendelijk.

Gebruiksscenario’s: Terraform vs. Crossplane

Wanneer Terraform te gebruiken?

Beste voor het beheren van infrastructuur buiten Kubernetes
Ideaal voor traditionele multi-cloud implementaties en VM’s
Sterk ecosysteem met uitgebreide modules en providers
Werkt goed met tools zoals Ansible, Packer en Vault voor automatisering

Wanneer Crossplane te gebruiken?

Ideaal voor op Kubernetes gerichte omgevingen
Ideaal voor GitOps-workflows (ArgoCD, Flux)
Mogelijkheid voor self-service provisioning via Kubernetes CRD’s
Geschikt voor multi-cloud Kubernetes-beheer (beheren van cloudservices via K8s API)

Aan de slag met Crossplane

Voor dit voorbeeld zullen we minikube gebruiken. Maar dezelfde stappen kunnen worden toegepast op elke Kubernetes-omgeving.

Stap 1: Implementeer MySQL in Kubernetes

1. Implementeer MySQL als een Deployment met een Service voor configuratie met behulp van Crossplane. Je kunt ook MySQL implementeren vanuit een andere locatie.

2. Definieer een mysql-deployment.yaml, die de secret, deployment en service aanmaakt die nodig zijn om MySQL uit te voeren.

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. Pas de YAML toe met het commando kubectl apply -f mysql-deployment.yaml.

4. Controleer of de pods actief zijn met het commando kubectl get pods.

5. Controleer de MySQL-verbinding door een tijdelijke SQL-pod te starten om de MySQL-implementatie te controleren. Maak de client aan met het commando kubectl run mysql-client --image=mysql:8.0 -it --rm -- bash.

6. Verbind met MySQL binnen de pod met het commando mysql -h mysql-service.default.svc.cluster.local -uroot -ppassword.

Stap 2:Installeer Crossplane op Kubernetes

1. Installeer Crossplane met behulp van 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

Let op: Het duurt even voordat Crossplane operationeel is.

2. Verifieer de installatie van Crossplane met het commando kubectl get pods -n crossplane-system.

Stap 3: Installeer de Crossplane Provider voor SQL

1. Definieer een MySQL-provider met behulp van de onderstaande YAML-inhoud.

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. Maak de provider aan met het commando kubectl apply -f provider.yaml.

3. Verifieer de provider met de volgende commando’s: kubectl get pods -n crossplane-system en kubectl get providers.

Let op: SQL-providers hebben enkele minuten nodig om operationeel te worden.

Stap 4: Configureer de Crossplane MySQL-provider

De providerconfiguratie vertelt Crossplane hoe te authenticeren met MySQL. Definieer de geheimen die moeten worden aangemaakt voor gebruik door de provider. Werk de stringData dienovereenkomstig bij in de onderstaande YAML. Pas de YAML toe met 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"

Pas de onderstaande providerconfiguratie toe voor Crossplane, die de bovenstaande geheimen gebruikt. Pas het toe met het commando 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

​

Verifieer de creatie van de providerconfiguratie met de commando’s — kubectl get providerconfigs.mysql.sql.crossplane.io en kubectl get crds | grep providerconfig.

Stap 5. Maak een MySQL-database aan met behulp van Crossplane

Gebruik nu Crossplane om een nieuwe database te provisioneren. Gebruik de onderstaande YAML en pas toe met 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

Stap 6: Verifieer de Database Creatie

Verifieer de database creatie met behulp van het commando kubectl get database.mysql.sql.crossplane.io/my-database.

Gebruik dezelfde verificatiestappen die in Stap 1 zijn genoemd om verbinding te maken met MySQL om de creatie van de database te verifiëren.

Met de bovenstaande stappen heb je Crossplane geïnstalleerd, de MySQL provider geconfigureerd en Crossplane gebruikt om een database te provisioneren.

Kunnen Terraform en Crossplane Samen Werken?

Terraform en Crossplane kunnen samen worden gebruikt voor vele scenario’s.

Scenario 1

In een volledig IaC scenario kan Terraform worden gebruikt om Kubernetes clusters op te zetten, en vervolgens kan Crossplane worden gebruikt om cloud resources te beheren vanuit Kubernetes. Terraform kan ook Crossplane zelf implementeren. Dit voorbeeld van een Hybride Workflow kan zijn

Terraform provisioneert de Kubernetes cluster in elke cloud provider.
Crossplane beheert cloud services (databases, opslag en netwerken) met behulp van Kubernetes CRD’s.

Scenario 2

Crossplane ondersteunt ook een Terraform provider, die kan worden gebruikt om Terraform-scripts uit te voeren als onderdeel van het IaC-model van Crossplane. Het uitvoeren van een Terraform provider voor Crossplane kan nuttig zijn in verschillende scenario’s waar de inheemse providers van Crossplane nog geen ondersteuning bieden voor bepaalde cloudresources of functionaliteiten. Hier zijn de redenen om een Terraform provider voor Crossplane uit te voeren:

Terraform heeft een uitgebreid ecosysteem van providers die veel cloudservices ondersteunen waarvoor Crossplane nog geen inheemse providers heeft.
Wanneer een organisatie al Terraform gebruikt voor infrastructuurbeheer, is er geen noodzaak om alles opnieuw te schrijven in Crossplane CRD’s.
Crossplane ondersteunt multi-cloudbeheer, maar de inheemse providers dekken mogelijk niet elke on-premise of SaaS-integratie.
Voor organisaties die geleidelijk willen overstappen van Terraform naar Crossplane, kunnen Terraform-providers binnen Crossplane fungeren als een hybride oplossing voordat de volledige migratie plaatsvindt.
Het uitvoeren van Terraform binnen Crossplane brengt Terraform onder het declaratieve GitOps-model van Kubernetes.

Stappen om IBM Cloud Cloudant DB te maken met behulp van Crossplane

Stap 1. Definieer de 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

​

Stap 2. Configureer de provider.

YAML

apiVersion: tf.upbound.io/v1beta1

kind: ProviderConfig

metadata:

  name: terraform-provider-ibm

spec: {}

​

Stap 3. Lever een Cloudant DB in IBM Cloud door gebruik te maken van Terraform-scripts als onderdeel van 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>"

​

Dit voorziet in een Cloudant DB met de naam crossplanecloudant in IBM Cloud.

Hoe Crossplane past in Platform Engineering

Platform engineering richt zich op het bouwen en onderhouden van interne ontwikkelaarsplatforms (IDP’s) die de infrastructuurbeheer en applicatie-implementatie vereenvoudigen. Crossplane speelt hierbij een belangrijke rol door een op Kubernetes gebaseerde benadering mogelijk te maken.

Crossplane zorgt voor declaratieve, self-service en op beleid gebaseerde voorziening van cloudresources. Crossplane-functies zoals declaratieve infrastructuur met K8s-API’s, aangepaste abstracties voor infra en apps, beveiliging en nalevingsrichtlijnen, versiebeheerde en geautomatiseerde implementaties, en continue correctie van afwijkingen helpen bij platformengineering.

Conclusie

Crossplane verandert hoe we cloudinfrastructuur beheren door IaC naar het Kubernetes-ecosysteem te brengen. Kubernetes-API’s maken een werkelijk declaratieve en op GitOps gebaseerde benadering mogelijk voor het voorzien en beheren van cloudresources. Als je al Kubernetes gebruikt en je IaC-strategie wilt moderniseren, is Crossplane zeker het verkennen waard.

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