# 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](https://www.ionos.com/pt-br/digitalguide/servidor/conhecimento/banco-de-dados-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](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/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`: ```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: ```bash 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: ```yaml apiVersion: v1 kind: PersistentVolumeClaim metadata: name: mariadb-pvc spec: accessModes: - ReadWriteOnce resources: requests: storage: 10Gi ``` Aplique esta configuração: ```bash kubectl apply -f mariadb-pvc.yaml ``` Em seguida, verifique se o armazenamento foi vinculado com sucesso: ```bash 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: ```yaml 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: ```bash 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`. ```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: ```bash kubectl apply -f mariadb-statefulset.yaml ``` Verifique se está tudo correto com: ```bash 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: ```yaml 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: ```bash kubectl apply -f mariadb-service.yaml ``` Verifique se o serviço está disponível: ```bash 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: ```bash 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: ```sql 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: ```bash 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: ```bash kubectl get statefulset mariadb ``` Você deve ver `READY 3/3` agora. Verifique os pods em execução: ```bash 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: ```bash 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. Dica Mais orientações sobre MariaDB podem ser encontradas em tutoriais para [instalar MariaDB via Docker](https://www.ionos.com/pt-br/digitalguide/hospedagem/tecnologia-de-hospedagem/mariadb-via-docker/) e instalar MariaDB no Proxmox. This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/hospedagem/tecnologia-de-hospedagem/mariadb-via-kubernetes/](https://www.ionos.com/pt-br/digitalguide/hospedagem/tecnologia-de-hospedagem/mariadb-via-kubernetes/) for AI/LLM consumption.