Instalar MariaDB via Ku­ber­ne­tes: ins­ta­la­ção passo a passo

O MariaDB pode ser operado de forma escalável e segura com o Ku­ber­ne­tes. Neste guia, você criará um Sta­te­ful­Set, integrará um volume per­sis­tente e con­fi­gu­rará o acesso ao serviço de banco de dados. Assim, você integra o MariaDB de forma per­ma­nente e con­tro­lada no seu cluster Ku­ber­ne­tes.

Vantagens da com­bi­na­ção MariaDB com Ku­ber­ne­tes

Ku­ber­ne­tes ajuda a iniciar, escalar e monitorar o MariaDB de forma confiável. Ele distribui cargas de trabalho de maneira in­te­li­gente e garante que o banco de dados reinicie au­to­ma­ti­ca­mente em caso de falhas. Com Ku­ber­ne­tes, você pode usar os recursos de forma eficiente e gerenciar sua in­fra­es­tru­tura com mais fa­ci­li­dade, tanto na nuvem quanto lo­cal­mente no data center.

Re­qui­si­tos

Antes de começar, verifique se os seguintes re­qui­si­tos estão atendidos:

• Um cluster Ku­ber­ne­tes em fun­ci­o­na­mento deve estar dis­po­ní­vel (por exemplo, Minikube, AKS, EKS ou VKE)
• kubectl está con­fi­gu­rado em sua máquina local
• Você tem acesso a um terminal com direitos de ad­mi­nis­tra­dor no cluster
• Opcional: uma Sto­ra­ge­Class ou HostPath con­fi­gu­rado lo­cal­mente para a per­sis­tên­cia

Instalar MariaDB via Ku­ber­ne­tes: passo a passo

Mos­tra­re­mos a seguir como realizar o deploy do MariaDB via Ku­ber­ne­tes e armazenar os dados per­ma­nen­te­mente. In­for­ma­ções de­ta­lha­das sobre Ku­ber­ne­tes você encontra em nosso tutorial Ku­ber­ne­tes.

Passo 1: con­fi­gu­rar Per­sis­tent­Vo­lume (PV) e PVC

MariaDB via Ku­ber­ne­tes necessita de ar­ma­ze­na­mento per­sis­tente para os conteúdos do banco de dados. Para garantir que estes dados sejam mantidos após uma rei­ni­ci­a­li­za­ção ou re-im­ple­men­ta­ção, con­fi­gu­ra­mos um Per­sis­tent­Vo­lume (PV) e uma cor­res­pon­dente Per­sis­tent­Vo­lu­me­Claim (PVC).

O PV define um local de ar­ma­ze­na­mento 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 pre­ser­va­dos após a exclusão da PVC. Aplique o PV:

kubectl apply -f mariadb-pv.yaml

A PVC reserva espaço de ar­ma­ze­na­mento 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 con­fi­gu­ra­ção:

kubectl apply -f mariadb-pvc.yaml

Em seguida, verifique se o ar­ma­ze­na­mento foi vinculado com sucesso:

kubectl get pvc mariadb-pvc

Se o status Bound for exibido, tudo está cor­re­ta­mente vinculado.

Passo 2: criar ConfigMap com my.cnf

Para que o MariaDB esteja con­fi­gu­rado de maneira ideal, crie um arquivo de con­fi­gu­ra­ção per­so­na­li­zado por meio de uma ConfigMap. Este será pos­te­ri­or­mente vinculado ao contêiner. Crie o arquivo mariadb-config.yaml com estas con­fi­gu­ra­çõ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 ex­ter­na­mente (bind-address), que você utilize opções de ar­ma­ze­na­mento modernas como InnoDB e que até 1000 conexões sejam possíveis.

Ative a con­fi­gu­ra­ção:

kubectl apply -f mariadb-config.yaml

Passo 3: criar Sta­te­ful­Set para MariaDB

Um Sta­te­ful­Set garante que cada Pod no cluster tenha uma iden­ti­dade fixa e ar­ma­ze­na­mento estável. Assim, todas as ins­tân­cias do banco de dados mantêm sua as­so­ci­a­ção a um volume es­pe­cí­fico mesmo após uma rei­ni­ci­a­li­za­çã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 Sta­te­ful­Set:

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-Ku­ber­ne­tes estará exe­cu­tando com sucesso no cluster.

Passo 4: con­fi­gu­rar acesso por meio de um serviço Ku­ber­ne­tes

Para que outras apli­ca­ções dentro do cluster possam acessar o MariaDB, pre­ci­sa­mos de um serviço Ku­ber­ne­tes. Crie o arquivo mariadb-service.yaml com a seguinte con­fi­gu­ra­ção:

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

Com este serviço, o pod MariaDB-Ku­ber­ne­tes pode ser acessado por um nome DNS fixo (mariadb). Ative a con­fi­gu­ra­ção:

kubectl apply -f mariadb-service.yaml

Verifique se o serviço está dis­po­ní­vel:

kubectl get svc mariadb

Você deve ver um endereço IP interno e a porta 3306. Essas in­for­ma­ções são im­por­tan­tes para o próximo passo.

Passo 5: conexão com a instância do MariaDB Ku­ber­ne­tes

Para verificar se o serviço de banco de dados está fun­ci­o­nando cor­re­ta­mente, você pode iniciar um pod tem­po­rá­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 Sta­te­ful­Set

Uma grande vantagem do Ku­ber­ne­tes é a fácil es­ca­la­bi­li­dade. Se sua aplicação gerar mais carga ou precisar de várias conexões si­mul­ta­ne­a­mente, você pode expandir o MariaDB com mais ins­tân­cias. 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 Ku­ber­ne­tes a criar dois pods adi­ci­o­nais além do existente. Cada pod recebe uma iden­ti­dade própria (por exemplo, mariadb-0, mariadb-1, mariadb-2) e um volume próprio.

Verifique o status da es­ca­la­bi­li­dade 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 eco­no­mi­zar recursos de teste, pode reduzir o número de pods novamente:

kubectl scale statefulset mariadb --replicas=1

Após um curto período, o Ku­ber­ne­tes remove os pods adi­ci­o­nais. Apenas mariadb-0 permanece. Os dados nos volumes dos pods excluídos são mantidos pela ar­qui­te­tura do Sta­te­ful­Set, desde que você não exclua o volume ma­nu­al­mente.