Codifique sua nuvem e Kubernetes com Crossplane e IaC

Tutoriais

Kubernetes MySQL

À medida que as organizações adotam o Kubernetes para aplicações nativas de nuvem, gerenciar a infraestrutura de forma eficiente se torna 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.

O 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 de Kubernetes de código aberto que permite provisionar e gerenciar 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 exigem execução externa, como scripts do Terraform sendo executados externamente, o Crossplane incorpora o gerenciamento de 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 infraestrutura fora do Kubernetes
Ideal para implantações tradicionais multi-nuvem 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 no Kubernetes
Ideal para fluxos de trabalho do GitOps (ArgoCD, Flux)
Permite a autoaprovisionamento via CRDs do Kubernetes
Bom para controle de Kubernetes em várias nuvens (gerenciando serviços em nuvem via API do K8s)

Começando com o Crossplane

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

Passo 1: Implantar o 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. Definir um mysql-deployment.yaml, que cria o segredo, o deployment 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. Aplicar o YAML usando o comando kubectl apply -f mysql-deployment.yaml.

4. Verificar se os pods estão ativos usando o comando kubectl get pods.

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

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

Passo 2: Instalar 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

Observação: 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: Instalar 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.

Observação: Os provedores SQL levam alguns minutos para iniciar.

Passo 4: Configurar 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 conforme necessário no 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-o 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. Criar 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.

Utilize 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 Trabalhar Juntos?

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

Cenário 1

Em um cenário completo de IaC, o Terraform pode ser usado para inicializar clusters Kubernetes e depois 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 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 IaC do Crossplane. Executar um provedor Terraform para Crossplane pode ser útil em vários cenários onde os provedores nativos do Crossplane ainda não suportam determinados recursos ou funcionalidades na nuvem. Seguem as razões para executar um provedor Terraform para Crossplane:

O Terraform possui um vasto ecossistema de provedores, suportando muitos serviços de 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 cobrir todas as integrações locais ou SaaS.
Para organizações que desejam fazer uma transição gradual do Terraform para o Crossplane, usar provedores Terraform dentro do Crossplane pode atuar 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 o 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 internas para desenvolvedores (IDPs) que simplificam o gerenciamento de infraestrutura e implantação de aplicativos. O Crossplane desempenha um papel significativo nisso, permitindo uma abordagem nativa do Kubernetes.

O Crossplane garante o provisionamento declarativo, self-service e orientado por políticas de recursos na nuvem. Recursos do Crossplane como infraestrutura declarativa com APIs do K8s, abstrações personalizadas para infraestrutura e aplicativos, diretrizes de segurança e conformidade, implantações automatizadas e controladas por versão, e correção contínua de desvios auxiliam na 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 pelo GitOps para o provisionamento e gerenciamento de recursos na nuvem. Se você já está utilizando 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