Codifique sua nuvem e Kubernetes com Crossplane e IaC

Tutoriais

Kubernetes MySQL

À medida que as organizações adotam o Kubernetes para aplicações nativas na nuvem, a gestão eficiente da infraestrutura torna-se um desafio. Ferramentas tradicionais de Infraestrutura como Código (IaC), como Terraform, Pulumi e outras, fornecem configurações declarativas, mas carecem de integração perfeita nos fluxos de trabalho nativos do Kubernetes.

Crossplane efetivamente preenche a lacuna entre o Kubernetes e a infraestrutura de nuvem nessa situação. Neste blog, exploraremos como o Crossplane possibilita o IaC para o Kubernetes e além.

O Que É o Crossplane?

O Crossplane é um complemento Kubernetes de código aberto que permite a você provisionar e gerenciar a infraestrutura de nuvem usando Definições de Recursos Personalizados do Kubernetes (CRDs) e a API do Kubernetes. Ao contrário das ferramentas tradicionais de IaC que requerem execução externa, como scripts do Terraform sendo executados externamente, o Crossplane incorpora a gestão da infraestrutura no Kubernetes. Isso o torna verdadeiramente declarativo e amigável ao GitOps.

Casos de Uso: Terraform vs. Crossplane

Quando Usar o Terraform?

Melhor para gerenciar a infraestrutura fora do Kubernetes
Ideal para implantações tradicionais de múltiplas nuvens e VMs
Ecosistema forte com extensos módulos e provedores
Funciona bem com ferramentas como Ansible, Packer e Vault para automação

Quando Usar o Crossplane?

Melhor para ambientes centrados em Kubernetes
Ideal para fluxos de trabalho GitOps (ArgoCD, Flux)
Permite provisionamento self-service via CRDs do Kubernetes
Bom para controle multi-nuvem do Kubernetes (gerenciamento de serviços em nuvem via API do K8s)

Começando com o Crossplane

Para este exemplo, usaremos um minikube. Mas os mesmos passos podem ser aplicados a qualquer Kubernetes.

Passo 1: Implantar MySQL no Kubernetes

1. Implantar o MySQL como um Deployment com um Service para configuração usando o Crossplane. Você também pode usar o MySQL implantado de outro local.

2. Defina um mysql-deployment.yaml, que cria o segredo, a implantação e o serviço necessários para executar o 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. Aplique o YAML usando o comando kubectl apply -f mysql-deployment.yaml.

4. Verifique se os pods estão funcionando usando o comando kubectl get pods.

5. Verifique a conexão MySQL iniciando um pod SQL temporário para checar a implantação do MySQL. Crie o cliente usando o comando kubectl run mysql-client --image=mysql:8.0 -it --rm -- bash.

6. Conecte-se ao MySQL dentro do pod usando o comando mysql -h mysql-service.default.svc.cluster.local -uroot -ppassword.

Passo 2:Instale o Crossplane no Kubernetes

1. Instale o Crossplane usando o 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

Nota: O Crossplane leva alguns minutos para iniciar.

2. Verifique a instalação do Crossplane usando o comando kubectl get pods -n crossplane-system.

Passo 3: Instale o Provedor Crossplane para SQL

1. Defina um provedor MySQL usando o conteúdo YAML abaixo.

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. Crie o provedor usando o comando kubectl apply -f provider.yaml.

3. Verifique o provedor usando os seguintes comandos: kubectl get pods -n crossplane-system e kubectl get providers.

Nota: Os provedores SQL levam alguns minutos para iniciar.

Passo 4: Configure o Provedor MySQL do Crossplane

A configuração do provedor informa ao Crossplane como autenticar com o MySQL. Defina os segredos a serem criados para uso do provedor. Atualize o stringData de acordo com o YAML abaixo. Aplique o YAML usando 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"

Aplique a configuração do provedor abaixo para o Crossplane, que utiliza os segredos acima. Aplique usando o comando 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

​

Verifique a criação da configuração do provedor usando os comandos — kubectl get providerconfigs.mysql.sql.crossplane.io e kubectl get crds | grep providerconfig.

Passo 5. Crie um Banco de Dados MySQL Usando o Crossplane

Agora, use o Crossplane para provisionar um novo banco de dados. Use o YAML abaixo e aplique usando 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

Passo 6: Verificar a Criação do Banco de Dados

Verifique a criação do banco de dados usando o comando kubectl get database.mysql.sql.crossplane.io/my-database.

Use os mesmos passos de verificação mencionados no Passo 1 para se conectar ao MySQL e verificar a criação do banco de dados.

Com os passos acima, você instalou o Crossplane, configurou o provedor MySQL e usou o Crossplane para provisionar um banco de dados.

O Terraform e o Crossplane Podem Funcionar Juntos?

O Terraform e o Crossplane podem ser usados juntos em muitos cenários.

Cenário 1

Em um cenário completo de IaC, o Terraform pode ser usado para inicializar clusters do Kubernetes e, em seguida, o Crossplane pode ser usado para gerenciar recursos de nuvem de dentro do Kubernetes. O Terraform também pode implantar o próprio Crossplane. Este Exemplo de Fluxo de Trabalho Híbrido pode ser

O Terraform provisiona o cluster do Kubernetes em qualquer provedor de nuvem.
O Crossplane gerencia serviços de nuvem (bancos de dados, armazenamento e rede) usando CRDs do Kubernetes.

Cenário 2

Crossplane também suporta um provedor Terraform, que pode ser usado para executar scripts Terraform como parte do modelo de IaC do Crossplane. Executar um provedor Terraform para o Crossplane pode ser útil em vários cenários onde os provedores nativos do Crossplane ainda não suportam certos recursos ou funcionalidades na nuvem. Seguem os motivos para executar um provedor Terraform para o Crossplane:

O Terraform possui um vasto ecossistema de provedores, suportando muitos serviços em nuvem para os quais o Crossplane ainda não possui provedores nativos.
Quando uma organização já utiliza o Terraform para gerenciamento de infraestrutura, não há necessidade de reescrever tudo em CRDs do Crossplane.
O Crossplane suporta gerenciamento multi-nuvem, mas seus provedores nativos podem não abranger todas as integrações on-premise ou SaaS.
Para organizações que desejam fazer uma transição gradual do Terraform para o Crossplane, o uso de provedores Terraform dentro do Crossplane pode funcionar como uma solução híbrida antes da migração completa.
Executar o Terraform dentro do Crossplane traz o Terraform para o modelo declarativo GitOps do Kubernetes.

Passos para Criar um Banco de Dados IBM Cloud Cloudant Usando o Crossplane

Passo 1. Definir o provedor Terraform.

YAML

apiVersion: pkg.crossplane.io/v1

kind: Provider

metadata:

  name: provider-terraform

spec:

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

​

Passo 2. Configurar o provedor.

YAML

apiVersion: tf.upbound.io/v1beta1

kind: ProviderConfig

metadata:

  name: terraform-provider-ibm

spec: {}

​

Passo 3. Provisionar um banco de dados Cloudant na IBM Cloud usando scripts Terraform como parte do 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>"

​

Isso provisiona um banco de dados Cloudant chamado crossplanecloudant na IBM Cloud.

Como o Crossplane se Encaixa na Engenharia de Plataformas

A engenharia de plataformas foca na construção e manutenção de plataformas de desenvolvedores internos (IDPs) que simplificam a gestão da infraestrutura e implantação de aplicações. O Crossplane desempenha um papel significativo nisso, possibilitando uma abordagem nativa do Kubernetes.

O Crossplane garante o provisionamento declarativo, self-service e baseado em políticas de recursos na nuvem. Recursos do Crossplane, como infraestrutura declarativa com APIs do K8s, abstrações personalizadas para infraestrutura e aplicações, diretrizes de segurança e conformidade, implantações controladas por versão e automatizadas, e correção contínua de desvios, auxiliam a engenharia de plataformas.

Conclusão

O Crossplane transforma a maneira como gerenciamos a infraestrutura de nuvem ao trazer o IaC para o ecossistema do Kubernetes. As APIs do Kubernetes permitem uma abordagem verdadeiramente declarativa e orientada por GitOps para o provisionamento e gerenciamento de recursos na nuvem. Se você já está usando o Kubernetes e deseja modernizar sua estratégia de IaC, o Crossplane definitivamente vale a pena explorar.

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