Instalar MariaDB via Kubernetes: instalação passo a passo

O MariaDB pode ser operado de forma escalável e segura com o Kubernetes. Neste guia, você criará um StatefulSet, integrará um volume persistente e configurará o acesso ao serviço de banco de dados. Assim, você integra o MariaDB de forma permanente e controlada no seu cluster Kubernetes.

Vantagens da combinação MariaDB com Kubernetes

Kubernetes ajuda a iniciar, escalar e monitorar o MariaDB de forma confiável. Ele distribui cargas de trabalho de maneira inteligente e garante que o banco de dados reinicie automaticamente em caso de falhas. Com Kubernetes, você pode usar os recursos de forma eficiente e gerenciar sua infraestrutura com mais facilidade, tanto na nuvem quanto localmente no data center.

Requisitos

Antes de começar, verifique se os seguintes requisitos estão atendidos:

• Um cluster Kubernetes em funcionamento deve estar disponível (por exemplo, Minikube, AKS, EKS ou VKE)
• kubectl está configurado em sua máquina local
• Você tem acesso a um terminal com direitos de administrador no cluster
• Opcional: uma StorageClass ou HostPath configurado localmente para a persistência

Instalar MariaDB via Kubernetes: passo a passo

Mostraremos a seguir como realizar o deploy do MariaDB via Kubernetes e armazenar os dados permanentemente. Informações detalhadas sobre Kubernetes você encontra em nosso tutorial Kubernetes.

Passo 1: configurar PersistentVolume (PV) e PVC

MariaDB via Kubernetes necessita de armazenamento persistente para os conteúdos do banco de dados. Para garantir que estes dados sejam mantidos após uma reinicialização ou re-implementação, configuramos um PersistentVolume (PV) e uma correspondente PersistentVolumeClaim (PVC).

O PV define um local de armazenamento físico no cluster, neste caso, /mnt/data/mariadb. Para isso, crie um arquivo YAML chamado mariadb-pv.yaml:

apiVersion: v1
kind: PersistentVolume
metadata:
    name: mariadb-pv
spec:
    capacity:
        storage: 10Gi
    accessModes:
        - ReadWriteOnce
    persistentVolumeReclaimPolicy: Retain
    hostPath:
        path: /mnt/data/mariadb

A entrada Retain garante que os dados sejam preservados após a exclusão da PVC. Aplique o PV:

kubectl apply -f mariadb-pv.yaml

A PVC reserva espaço de armazenamento do PV para o pod. Crie o arquivo mariadb-pvc.yaml com o seguinte conteúdo:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
    name: mariadb-pvc
spec:
    accessModes:
        - ReadWriteOnce
    resources:
        requests:
            storage: 10Gi

Aplique esta configuração:

kubectl apply -f mariadb-pvc.yaml

Em seguida, verifique se o armazenamento foi vinculado com sucesso:

kubectl get pvc mariadb-pvc

Se o status Bound for exibido, tudo está corretamente vinculado.

Passo 2: criar ConfigMap com my.cnf

Para que o MariaDB esteja configurado de maneira ideal, crie um arquivo de configuração personalizado por meio de uma ConfigMap. Este será posteriormente vinculado ao contêiner. Crie o arquivo mariadb-config.yaml com estas configurações:

apiVersion: v1
kind: ConfigMap
metadata:
    name: mariadb-config
    labels:
        app: mariadb
data:
    my.cnf: |
        [mysqld]
        bind-address=0.0.0.0
        default_storage_engine=InnoDB
        innodb_file_per_table=1
        max_connections=1000

Estas opções garantem que o MariaDB seja acessível externamente (bind-address), que você utilize opções de armazenamento modernas como InnoDB e que até 1000 conexões sejam possíveis.

Ative a configuração:

kubectl apply -f mariadb-config.yaml

Passo 3: criar StatefulSet para MariaDB

Um StatefulSet garante que cada Pod no cluster tenha uma identidade fixa e armazenamento estável. Assim, todas as instâncias do banco de dados mantêm sua associação a um volume específico mesmo após uma reinicialização. Primeiro, crie o arquivo mariadb-statefulset.yaml.

apiVersion: apps/v1
kind: StatefulSet
metadata:
    name: mariadb
spec:
    serviceName: "mariadb"
    replicas: 1
    selector:
        matchLabels:
            app: mariadb
    template:
        metadata:
            labels:
                app: mariadb
        spec:
            containers:
            - name: mariadb
                image: mariadb:latest
                ports:
                - containerPort: 3306
                    name: mariadb
                env:
                - name: MYSQL_ROOT_PASSWORD
                    value: "strong_password"
                volumeMounts:
                - name: mariadb-storage
                    mountPath: /var/lib/mysql
                - name: config-volume
                    mountPath: /etc/mysql/conf.d
            volumes:
            - name: config-volume
                configMap:
                    name: mariadb-config
    volumeClaimTemplates:
    - metadata:
            name: mariadb-storage
        spec:
            accessModes: ["ReadWriteOnce"]
            resources:
                requests:
                    storage: 10Gi

Aplique o StatefulSet:

kubectl apply -f mariadb-statefulset.yaml

Verifique se está tudo correto com:

kubectl get statefulset mariadb

Assim que READY 1/1 for exibido, seu primeiro pod MariaDB-Kubernetes estará executando com sucesso no cluster.

Passo 4: configurar acesso por meio de um serviço Kubernetes

Para que outras aplicações dentro do cluster possam acessar o MariaDB, precisamos de um serviço Kubernetes. Crie o arquivo mariadb-service.yaml com a seguinte configuração:

apiVersion: v1
kind: Service
metadata:
    name: mariadb
spec:
    ports:
    - port: 3306
        targetPort: 3306
    selector:
        app: mariadb

Com este serviço, o pod MariaDB-Kubernetes pode ser acessado por um nome DNS fixo (mariadb). Ative a configuração:

kubectl apply -f mariadb-service.yaml

Verifique se o serviço está disponível:

kubectl get svc mariadb

Você deve ver um endereço IP interno e a porta 3306. Essas informações são importantes para o próximo passo.

Passo 5: conexão com a instância do MariaDB Kubernetes

Para verificar se o serviço de banco de dados está funcionando corretamente, você pode iniciar um pod temporário que funcione como cliente MySQL. Execute o seguinte comando:

kubectl run -it --rm --image=mariadb mariadb-client -h mariadb -u root -p strong_password

Após inserir a senha, você acessará o console SQL. Teste, por exemplo, exibindo os bancos de dados:

SHOW DATABASES;

Você deve ver bancos de dados padrão como mysql, information_schema ou performance_schema. Para sair, digite exit.

Passo 6: escalar StatefulSet

Uma grande vantagem do Kubernetes é a fácil escalabilidade. Se sua aplicação gerar mais carga ou precisar de várias conexões simultaneamente, você pode expandir o MariaDB com mais instâncias. Na prática, isso ocorre com o ajuste das réplicas. Execute este comando para iniciar três pods:

kubectl scale statefulset mariadb --replicas=3

Esta expressão instrui o Kubernetes a criar dois pods adicionais além do existente. Cada pod recebe uma identidade própria (por exemplo, mariadb-0, mariadb-1, mariadb-2) e um volume próprio.

Verifique o status da escalabilidade com:

kubectl get statefulset mariadb

Você deve ver READY 3/3 agora. Verifique os pods em execução:

kubectl get pods -l app=mariadb

Quando a carga adicional passar ou se você quiser economizar recursos de teste, pode reduzir o número de pods novamente:

kubectl scale statefulset mariadb --replicas=1

Após um curto período, o Kubernetes remove os pods adicionais. Apenas mariadb-0 permanece. Os dados nos volumes dos pods excluídos são mantidos pela arquitetura do StatefulSet, desde que você não exclua o volume manualmente.