Codifica tu nube y Kubernetes con Crossplane e IaC

A medida que las organizaciones adoptan Kubernetes para aplicaciones nativas de la nube, la gestión eficiente de la infraestructura se vuelve desafiante. Herramientas tradicionales de Infraestructura como Código (IaC) como Terraform, Pulumi y otros proporcionan configuraciones declarativas pero carecen de una integración fluida en los flujos de trabajo nativos de Kubernetes.

Crossplane resuelve eficazmente la brecha entre Kubernetes e infraestructura en la nube en esta situación. En esta publicación, exploraremos cómo Crossplane permite el IaC para Kubernetes y más allá.

¿Qué es Crossplane?

Crossplane es un complemento de Kubernetes de código abierto que le permite aprovisionar y gestionar infraestructura en la nube utilizando Definiciones de Recursos Personalizados (CRDs) de Kubernetes y la API de Kubernetes. A diferencia de las herramientas tradicionales de IaC que requieren ejecución externa, como la ejecución externa de scripts de Terraform, Crossplane incrusta la gestión de la infraestructura en Kubernetes. Esto lo hace verdaderamente declarativo y compatible con GitOps.

Casos de Uso: Terraform vs. Crossplane

¿Cuándo usar Terraform?

• Mejor para gestionar infraestructura fuera de Kubernetes
• Ideal para implementaciones tradicionales de múltiples nubes y máquinas virtuales
• Gran ecosistema con módulos y proveedores extensos
• Funciona bien con herramientas como Ansible, Packer y Vault para la automatización

¿Cuándo utilizar Crossplane?

• Mejor para entornos centrados en Kubernetes
• Ideal para flujos de trabajo de GitOps (ArgoCD, Flux)
• Permite la provisión de autoservicio a través de CRDs de Kubernetes
• Bueno para el control de Kubernetes multi-nube (gestión de servicios en la nube a través de la API de K8s)

Empezando con Crossplane

Para este ejemplo, utilizaremos un minikube. Pero los mismos pasos se pueden aplicar a cualquier clúster de Kubernetes.

Paso 1: Desplegar MySQL en Kubernetes

1. Despliega MySQL como un Deployment con un Service para configurar usando Crossplane. También puedes usar MySQL desplegado desde otra ubicación.

2. Define un mysql-deployment.yaml, que crea el secreto, el deployment y el service necesarios para ejecutar MySQL.

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. Aplica el YAML usando el comando kubectl apply -f mysql-deployment.yaml.

4. Verifica que los pods estén activos usando el comando kubectl get pods.

5. Verifica la conexión a MySQL iniciando un pod SQL temporal para verificar el despliegue de MySQL. Crea el cliente usando el comando kubectl run mysql-client --image=mysql:8.0 -it --rm -- bash.

6. Conéctate a MySQL dentro del pod usando el comando mysql -h mysql-service.default.svc.cluster.local -uroot -ppassword.

Paso 2:Instalar Crossplane en Kubernetes

1. Instalar Crossplane usando Helm:

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

Nota: Crossplane tarda unos minutos en iniciarse.

2. Verificar la instalación de Crossplane usando el comando kubectl get pods -n crossplane-system.

Paso 3: Instalar el Proveedor de SQL de Crossplane

1. Definir un proveedor de MySQL utilizando el contenido YAML a continuación.

apiVersion: pkg.crossplane.io/v1

kind: Provider

metadata:

  name: provider-sql

spec:

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

2. Crear el proveedor usando el comando kubectl apply -f provider.yaml.

3. Verificar el proveedor usando los siguientes comandos: kubectl get pods -n crossplane-system y kubectl get providers.

Nota: Los proveedores de SQL tardan unos minutos en iniciarse.

Paso 4: Configurar el Proveedor de MySQL de Crossplane

La configuración del proveedor le indica a Crossplane cómo autenticarse con MySQL. Defina los secretos que se crearán para el uso del proveedor. Actualice el stringData según corresponda en el YAML a continuación. Aplique el YAML usando kubectl apply -f mysql-secret.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"

Aplique la siguiente configuración de proveedor para Crossplane, que utiliza los secretos anteriores. Aplíquelo usando el comando kubectl apply -f providerconfig.yaml.

apiVersion: mysql.sql.crossplane.io/v1alpha1

kind: ProviderConfig

metadata:

  name: mysql-provider

spec:

  credentials:

    source: MySQLConnectionSecret

    connectionSecretRef:

      name: mysql-conn-secret

      namespace: default

​

Verifique la creación de la configuración del proveedor usando los comandos — kubectl get providerconfigs.mysql.sql.crossplane.io y kubectl get crds | grep providerconfig.

Paso 5. Crear una Base de Datos MySQL Usando Crossplane

Ahora, usa Crossplane para aprovisionar una nueva base de datos. Usa el siguiente YAML y aplícalo usando kubectl apply -f mysqlinstance.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

Paso 6: Verificar la Creación de la Base de Datos

Verifica la creación de la base de datos usando el comando kubectl get database.mysql.sql.crossplane.io/my-database.

Utiliza los mismos pasos de verificación mencionados en el Paso 1 para conectarte a MySQL y verificar la creación de la base de datos.

Con los pasos anteriores, has instalado Crossplane, configurado el proveedor de MySQL y utilizado Crossplane para aprovisionar una base de datos.

¿Pueden Terraform y Crossplane Trabajar Juntos?

Terraform y Crossplane pueden ser utilizados juntos en muchos escenarios.

Escenario 1

En un escenario completo de IaC, Terraform puede ser utilizado para inicializar clústeres de Kubernetes, y luego Crossplane puede ser utilizado para gestionar recursos en la nube desde dentro de Kubernetes. Terraform también puede desplegar Crossplane en sí mismo. Este Ejemplo de Flujo de Trabajo Híbrido puede ser

• Terraform aprovisiona el clúster de Kubernetes en cualquier proveedor de nube.
• Crossplane gestiona servicios en la nube (bases de datos, almacenamiento y redes) utilizando CRDs de Kubernetes.

Escenario 2

Crossplane también admite un proveedor de Terraform, que se puede utilizar para ejecutar scripts de Terraform como parte del modelo IaC de Crossplane. Ejecutar un proveedor de Terraform para Crossplane puede ser útil en varios escenarios donde los proveedores nativos de Crossplane aún no admiten ciertos recursos o funcionalidades en la nube. A continuación, se presentan las razones para ejecutar un proveedor de Terraform para Crossplane:

• Terraform tiene un vasto ecosistema de proveedores, que admiten muchos servicios en la nube para los cuales Crossplane puede no tener aún proveedores nativos.
• Cuando una organización ya utiliza Terraform para la gestión de infraestructura, no es necesario reescribir todo en los CRDs de Crossplane.
• Crossplane admite la gestión multicloud, pero sus proveedores nativos pueden no cubrir cada integración local o SaaS.
• Para las organizaciones que buscan una transición gradual de Terraform a Crossplane, utilizar proveedores de Terraform dentro de Crossplane puede actuar como una solución híbrida antes de la migración completa.
• Ejecutar Terraform dentro de Crossplane lleva Terraform al modelo declarativo GitOps de Kubernetes.

Pasos para crear una base de datos Cloudant en IBM Cloud usando Crossplane

Paso 1. Definir el proveedor de Terraform.

apiVersion: pkg.crossplane.io/v1

kind: Provider

metadata:

  name: provider-terraform

spec:

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

​

Paso 2. Configurar el proveedor.

apiVersion: tf.upbound.io/v1beta1

kind: ProviderConfig

metadata:

  name: terraform-provider-ibm

spec: {}

​

Paso 3. Provisionar una base de datos Cloudant en IBM Cloud utilizando scripts de Terraform como parte de Crossplane.

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

​

Esto provisiona una base de datos Cloudant llamada crossplanecloudant en IBM Cloud.

Cómo encaja Crossplane en la ingeniería de plataformas

La ingeniería de plataformas se centra en construir y mantener plataformas internas para desarrolladores (IDPs) que simplifican la gestión de infraestructura y el despliegue de aplicaciones. Crossplane desempeña un papel significativo en esto al permitir un enfoque nativo de Kubernetes.

Crossplane asegura un aprovisionamiento declarativo, autoservicio y basado en políticas de recursos en la nube. Características de Crossplane como infraestructura declarativa con API de K8s, abstracciones personalizadas para infraestructura y aplicaciones, barreas de seguridad y cumplimiento, despliegues controlados por versiones y automatizados, y corrección continua de deriva ayudan a la ingeniería de plataformas.

Conclusión

Crossplane transforma la forma en que gestionamos la infraestructura en la nube al incorporar IaC en el ecosistema de Kubernetes. Las API de Kubernetes permiten un enfoque verdaderamente declarativo y guiado por GitOps para el aprovisionamiento y gestión de recursos en la nube. Si ya estás utilizando Kubernetes y buscas modernizar tu estrategia de IaC, definitivamente vale la pena explorar Crossplane.