MySQL Docker: Guia Completo

Publicado em por

Se estás interessado em bases de dados e containers, aqui tens um guia completo sobre como instalar o MySQL no Docker. O MySQL é uma das bases de dados mais confiáveis do mundo, e usar o Docker com ele pode trazer várias vantagens para o teu desenvolvimento e deploy.

Neste post, vais aprender a instalar o MySQL no Docker, explorar o seu Dockerfile e entender como configurá-lo corretamente. Vamos descobrir como usar o MySQL para Docker containers, facilitando o seu uso em ambientes de nuvem ou em testes.

Instalação do Docker

O Docker está disponível para vários sistemas operativos. Dependendo do seu SO, o processo de instalação varia ligeiramente. Abordaremos a instalação no Windows, macOS e Linux.

Instalar o Docker Desktop no Windows

Para Windows, o Docker Desktop é a solução recomendada. Siga estes passos:

  1. Descarregar o Docker Desktop: Vá ao site do Docker e descarregue o instalador do Docker Desktop para Windows. Certifique-se de que o seu sistema cumpre os requisitos mínimos, incluindo ter o Windows 10 de 64 bits ou posterior com o Hyper-V ativado.https://www.docker.com/products/docker-desktop

  2. Executar o Instalador: Dê um duplo clique no instalador descarregado para iniciar o processo de instalação. Siga as instruções no ecrã.

  3. Ativar o WSL 2: O Docker Desktop requer o Subsistema Windows para Linux 2 (WSL 2). Se ainda não o fez, ative-o seguindo as indicações durante a instalação ou ativando-o manualmente através do PowerShell:

    wsl --install

    Este comando instala os componentes necessários.

  4. Reinicie o seu Computador: Após a instalação, reinicie o seu computador para aplicar as alterações.

  5. Iniciar o Docker Desktop: Assim que reiniciar, inicie o Docker Desktop a partir do menu Iniciar. Aceite os termos e condições.

  6. Verificar a Instalação: Abra a Linha de Comandos ou o PowerShell e execute:

    docker --version

    Este comando deverá apresentar a versão instalada do Docker, confirmando uma instalação bem-sucedida.

Para mais detalhes, consulte a nossa página sobre como instalar o Docker no Windows.

Instalar o Docker Desktop no MacOS

O Docker Desktop para macOS fornece uma interface amigável para gerir os contentores Docker. Eis como instalá-lo:

  1. Descarregar o Docker Desktop: Visite o site do Docker e descarregue o instalador do Docker Desktop para macOS.

    https://www.docker.com/products/docker-desktop

  2. Executar o Instalador: Dê um duplo clique no ficheiro .dmg descarregado e arraste o ícone do Docker para a pasta Aplicações.

  3. Iniciar o Docker Desktop: Abra o Docker Desktop a partir da pasta Aplicações. Aceite os termos e condições.

  4. Conceder Permissões: Poderá ser solicitado a conceder permissões ao Docker Desktop para aceder a determinadas pastas. Siga as instruções no ecrã.

  5. Verificar a Instalação: Abra um terminal e execute:

    docker --version

    Este comando deverá apresentar a versão instalada do Docker.

Consulte o nosso artigo para obter mais detalhes sobre como instalar o Docker no MacOS.

Instalar o Docker Engine no Linux

No Linux, o Docker Engine é comummente utilizado. O processo de instalação varia consoante a distribuição. Eis como instalá-lo no Ubuntu/Debian e CentOS/RHEL.

Ubuntu/Debian

  1. Atualizar o Índice de Pacotes:

    sudo apt update

  2. Instalar Pacotes Necessários:

    sudo apt install apt-transport-https ca-certificates curl gnupg lsb-release

  3. Adicionar a Chave GPG do Docker:

    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

  4. Configurar o Repositório:


    echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

  5. Atualizar o Índice de Pacotes Novamente:

    sudo apt update

  6. Instalar o Docker Engine:

    sudo apt install docker-ce docker-ce-cli containerd.io

  7. Verificar a Instalação:

    sudo docker --version

CentOS/RHEL

  1. Instalar Pacotes Necessários:

    sudo yum install -y yum-utils

  2. Adicionar o Repositório Docker:

    sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo

  3. Instalar o Docker Engine:

    sudo yum install docker-ce docker-ce-cli containerd.io

  4. Iniciar o Serviço Docker:

    sudo systemctl start docker

  5. Ativar o Docker para Iniciar no Arranque:

    sudo systemctl enable docker

  6. Verificar a Instalação:

    sudo docker --version

Conhecimentos Básicos de Docker

Antes de criar um Dockerfile MySQL, é fundamental compreender as imagens e contentores Docker. Estes são os blocos de construção das aplicações Dockerizadas.

Compreender as Imagens Docker

Uma imagem Docker é um modelo de leitura que contém instruções para criar um contentor Docker. Inclui o código da aplicação, as bibliotecas, as dependências, as ferramentas e outros ficheiros necessários para executar a aplicação. As imagens são construídas a partir de um Dockerfile, um ficheiro de texto que contém todos os comandos necessários para montar a imagem. As imagens Docker são armazenadas num registo Docker, como o Docker Hub, que lhe permite partilhar e reutilizar imagens. Pense numa imagem Docker como uma fotografia de um sistema de ficheiros mais metadados.

Compreender os Contentores Docker

Um contentor Docker é uma instância executável de uma imagem Docker. É um ambiente isolado que executa a aplicação definida na imagem. Os contentores fornecem isolamento de processos e do sistema de ficheiros, garantindo que as aplicações são executadas de forma consistente em diferentes ambientes. Os contentores podem ser iniciados, parados, movidos e eliminados. Quando executa uma imagem Docker, cria um contentor. Podem ser criados vários contentores a partir da mesma imagem, cada um a ser executado no seu próprio ambiente isolado. Estes contentores partilham o kernel com o SO anfitrião, mas estão isolados uns dos outros.

Obter um conhecimento sólido destes pré-requisitos irá preparar o terreno para criar eficazmente um Dockerfile MySQL, otimizar as melhores práticas do Docker e gerir os seus contentores MySQL Docker de forma eficiente.

Criar o Dockerfile do MySQL

Agora que tem o Docker instalado e compreende os conceitos básicos, está na altura de criar o seu Dockerfile MySQL. Este ficheiro conterá todas as instruções necessárias para construir a sua imagem MySQL Docker. Iremos analisar cada passo em detalhe para garantir que compreende o processo de colocar o MySQL em contentores.

Passo 1: Criar um Novo Diretório

Primeiro, crie um novo diretório para o seu Dockerfile e ficheiros de configuração relacionados. Isto mantém o seu projeto organizado.

mkdir mysql-dockercd mysql-docker

Passo 2: Criar um Dockerfile

Dentro do diretório mysql-docker, crie um ficheiro com o nome Dockerfile (sem extensão de ficheiro). Este ficheiro irá conter as instruções para construir a sua imagem Docker.

touch Dockerfile

Abra o Dockerfile num editor de texto. Irá adicionar instruções ao mesmo nos passos seguintes.

Passo 3: Especificar a Imagem Base

A primeira instrução no seu Dockerfile deve especificar a imagem base. Para o MySQL, é melhor usar a imagem oficial do MySQL do Docker Hub. Esta imagem é mantida pela equipa do MySQL e inclui todos os componentes necessários para executar um servidor MySQL.

Usar a Imagem Oficial do MySQL

Adicione a seguinte linha ao seu Dockerfile:

FROM mysql:8.0

Esta linha diz ao Docker para usar a imagem MySQL 8.0 como base para o seu contentor. Pode especificar outras versões do MySQL, se necessário (p. ex., mysql:5.7). Usar a imagem oficial garante que tem uma base segura e atualizada para a sua implementação MySQL. Esta é uma melhor prática do Docker para garantir segurança e fiabilidade.

Passo 4: Definir Variáveis de Ambiente

As variáveis de ambiente são cruciais para configurar o seu contentor MySQL. Permitem definir a palavra-passe root, o utilizador predefinido e outras definições importantes. Definir estas variáveis diretamente no Dockerfile é uma prática comum para simplificar, mas considere usar métodos mais seguros, como segredos do Docker ou ferramentas de gestão de configuração externa para ambientes de produção.

Definir a Palavra-Passe Root do MySQL

Defina a variável de ambiente MYSQL_ROOT_PASSWORD para definir a palavra-passe root. Este é um passo obrigatório para proteger a sua instância MySQL.

ENV MYSQL_ROOT_PASSWORD=sua_palavra_passe_root

Substitua sua_palavra_passe_root por uma palavra-passe forte. Importante: Para ambientes de produção, não codifique palavras-passe diretamente no Dockerfile. Use segredos do Docker ou outros métodos seguros para gerir informações confidenciais. Isto é fundamental para a segurança geral.

Definir o Utilizador e a Palavra-Passe do MySQL (Opcional)

Também pode criar um utilizador e uma base de dados predefinidos. Defina as variáveis de ambiente MYSQL_USER, MYSQL_PASSWORD e MYSQL_DATABASE.

ENV MYSQL_USER=seu_utilizadorENV MYSQL_PASSWORD=sua_palavra_passeENV MYSQL_DATABASE=sua_base_de_dados

Substitua seu_utilizador, sua_palavra_passe e sua_base_de_dados pelos valores desejados. Se omitir este passo, só será criado o utilizador root. Estas definições ajudam na criação de um contentor MySQL com acesso pré-configurado.

Passo 5: Expor a Porta do MySQL

Para permitir o acesso externo ao seu servidor MySQL, precisa de expor a porta 3306, que é a porta predefinida do MySQL.

EXPOSE 3306

Compreender o Mapeamento de Portas

A instrução EXPOSE informa o Docker que o contentor está à escuta na porta especificada em tempo de execução. No entanto, na realidade não publica a porta na máquina anfitriã. Para publicar a porta, precisa de usar a opção -p ao executar o contentor (p. ex., docker run -p 3306:3306 ...). O mapeamento de portas permite mapear a porta do contentor para uma porta diferente na máquina anfitriã, se necessário. Compreender o mapeamento de portas é essencial para gerir o acesso à rede à sua colocação em contentores da base de dados.

Passo 6: Adicionar Configuração Personalizada (Opcional)

Pode personalizar a configuração do MySQL fornecendo o seu próprio ficheiro my.cnf. Isto permite-lhe ajustar as definições do MySQL para desempenho ou segurança.

Criar um Ficheiro de Configuração Personalizado do MySQL

Crie um ficheiro my.cnf com as definições de configuração desejadas. Por exemplo:

[mysqld]innodb_buffer_pool_size=2Gcharacter-set-server=utf8mb4collation-server=utf8mb4_unicode_ci

Guarde este ficheiro no mesmo diretório que o seu Dockerfile.

Copiar o Ficheiro de Configuração para o Contentor

Adicione uma instrução COPY ao seu Dockerfile para copiar o ficheiro my.cnf para a localização apropriada no contentor (normalmente /etc/mysql/conf.d/).

COPY my.cnf /etc/mysql/conf.d/my.cnf

Esta instrução copia o ficheiro de configuração durante o processo de construção da imagem, garantindo que as suas definições personalizadas são aplicadas quando o contentor é iniciado.

Passo 7: Definir o Ponto de Entrada (Opcional)

O ponto de entrada especifica o comando que será executado quando o contentor é iniciado. Embora a imagem oficial do MySQL tenha um ponto de entrada predefinido, poderá querer substituí-lo por um comportamento personalizado.

Compreender o Ponto de Entrada

O ponto de entrada pode ser um comando simples ou um script. É frequentemente usado para executar tarefas de inicialização ou para iniciar o processo principal da aplicação. Compreender o ponto de entrada ajuda-o a gerir o comportamento de início da sua instância MySQL em contentor.

Usar um Script de Ponto de Entrada Personalizado

Crie um script (p. ex., entrypoint.sh) com os comandos desejados:

#!/bin/bash# Comandos de inicialização personalizados aqui exec mysqld --user=mysql

Torne o script executável:

chmod +x entrypoint.sh

Adicione uma instrução COPY para copiar o script para o contentor e uma instrução ENTRYPOINT para definir o ponto de entrada:

COPY entrypoint.sh /usr/local/bin/entrypoint.shENTRYPOINT ["/usr/local/bin/entrypoint.sh"]

Esta configuração garante que o seu script personalizado é executado quando o contentor é iniciado, permitindo-lhe executar tarefas de inicialização adicionais antes de iniciar o servidor MySQL.

Construir a Imagem Docker

Depois de ter criado o seu Dockerfile, o passo seguinte é construir a imagem Docker. Este processo usa as instruções no seu Dockerfile para criar uma imagem executável que encapsula a sua base de dados MySQL.

Usar o Comando docker build

O comando docker build é usado para construir imagens Docker a partir de um Dockerfile. Navegue até ao diretório que contém o seu Dockerfile (mysql-docker no nosso exemplo) no seu terminal.

Em seguida, execute o seguinte comando:

docker build -t mysql-docker .

Vamos analisar este comando:

  • docker build: Este é o comando para construir uma imagem Docker.

  • -t mysql-docker: Esta opção atribui uma etiqueta (nome) à imagem. Neste caso, estamos a etiquetar a imagem como mysql-docker. A etiquetagem é crucial para identificar e gerir as suas imagens. Sem uma etiqueta, a imagem teria um ID gerado automaticamente, o que tornaria mais difícil referenciá-la. Pense na etiqueta como um alias legível por humanos.

  • .: Isto especifica o contexto de construção, que é o diretório que contém o Dockerfile e quaisquer outros ficheiros necessários para a construção (como o ficheiro my.cnf ou entrypoint.sh). O ponto (.) indica o diretório atual.

Durante o processo de construção, o Docker irá executar cada instrução no seu Dockerfile, passo a passo. Verá o resultado no terminal indicando o progresso de cada passo. Se algum passo falhar, a construção irá parar e terá de resolver o problema.

Dicas de Resolução de Problemas:

  • Verificar a Sintaxe do Dockerfile: Certifique-se de que as instruções do seu Dockerfile estão formatadas corretamente. Mesmo um pequeno erro de digitação pode fazer com que a construção falhe.

  • Verificar os Caminhos dos Ficheiros: Verifique novamente os caminhos especificados nas instruções COPY. Certifique-se de que os ficheiros existem nos locais corretos dentro do contexto de construção.

  • Problemas de Rede: Se a construção envolver o descarregamento de pacotes ou recursos da internet, certifique-se de que a sua ligação de rede está estável.

  • Espaço em Disco: Certifique-se de que tem espaço em disco suficiente no seu sistema, pois a construção de imagens pode consumir uma quantidade significativa de espaço.

Assim que a construção estiver concluída, o Docker irá apresentar uma mensagem de sucesso, juntamente com o ID da imagem.

Etiquetar a Imagem

Como mencionado anteriormente, a opção -t no comando docker build atribui uma etiqueta à imagem. Também pode etiquetar uma imagem existente usando o comando docker tag.

A sintaxe para etiquetar uma imagem é:

docker tag [id-da-imagem-existente] [novo-nome-da-imagem:etiqueta]

Por exemplo, se quiser etiquetar uma imagem com o ID abcdef123456 como mysql-docker:latest, executaria:

docker tag abcdef123456 mysql-docker:latest

Compreender as Etiquetas de Imagens:

  • Nome da Imagem: O nome da imagem (p. ex., mysql-docker).

  • Etiqueta: Um identificador de versão (p. ex., latest, 8.0). A etiqueta latest é frequentemente usada para se referir à versão mais recente da imagem. É melhor prática usar etiquetas de versão específicas (p. ex., 8.0.32) para reprodutibilidade e para evitar alterações inesperadas quando a imagem é atualizada.

Etiquetar as suas imagens corretamente ajuda no controlo de versão e torna mais fácil gerir diferentes versões das suas imagens MySQL Docker. Isto também é importante, pois melhora a organização e a capacidade de descoberta dos seus recursos Docker.

Ao seguir estes passos, pode construir com sucesso a sua imagem Docker MySQL e prepará-la para ser executada num contentor. Este processo é uma parte fundamental da colocação em contentores da base de dados e da implementação MySQL usando o Docker.

Executar o Contentor MySQL

Depois de construir a sua imagem Docker MySQL, o passo final é executá-la num contentor. Isto irá iniciar o servidor MySQL e permitir-lhe ligar-se ao mesmo. Iremos abordar os aspetos essenciais da execução do contentor, incluindo o mapeamento de portas, as variáveis de ambiente e o armazenamento de dados persistentes.

Usar o Comando docker run

O comando docker run é usado para criar e iniciar um contentor a partir de uma imagem Docker. Eis um exemplo básico:

docker run -d --name mysql-container -p 3306:3306 -e MYSQL_ROOT_PASSWORD=sua_palavra_passe_root mysql-docker

Vamos analisar este comando:

  • docker run: Este é o comando para executar um contentor Docker.

  • -d: Esta opção executa o contentor em modo destacado (em segundo plano). O modo destacado é ideal para serviços de longa duração, como bases de dados. Sem -d, o contentor seria executado em primeiro plano e o seu terminal seria anexado à saída do contentor.

  • --name mysql-container: Esta opção atribui um nome ao contentor. Nomear os seus contentores torna mais fácil geri-los e referenciá-los. Se não especificar um nome, o Docker irá gerar automaticamente um nome aleatório.

  • -p 3306:3306: Esta opção mapeia a porta 3306 na máquina anfitriã para a porta 3306 no contentor. Isto permite-lhe ligar-se ao servidor MySQL a partir da sua máquina anfitriã. O formato é porta_anfitriã:porta_contentor. Pode mapear para portas diferentes no anfitrião, se necessário (p. ex., -p 4000:3306 mapearia a porta 4000 do anfitrião para a porta 3306 do contentor).

  • -e MYSQL_ROOT_PASSWORD=sua_palavra_passe_root: Esta opção define a variável de ambiente MYSQL_ROOT_PASSWORD dentro do contentor. Estamos a passar a palavra-passe root que definimos anteriormente. É crucial definir isto por razões de segurança. Mais uma vez, para produção, considere usar segredos do Docker ou outros métodos seguros para passar informações confidenciais.

  • mysql-docker: Este é o nome da imagem Docker a executar (aquela que etiquetámos anteriormente).

Mapear Portas

O mapeamento de portas é essencial para aceder a serviços em execução dentro de um contentor Docker. A opção -p permite-lhe mapear portas entre o anfitrião e o contentor.

Exemplo:

docker run -p 3306:3306 mysql-docker

Este comando mapeia a porta 3306 no anfitrião para a porta 3306 no contentor. Pode então ligar-se ao servidor MySQL usando localhost:3306.

Definir Variáveis de Ambiente

As variáveis de ambiente são usadas para configurar o servidor MySQL dentro do contentor. Pode definir variáveis de ambiente usando a opção -e.

Exemplo:

docker run -e MYSQL_ROOT_PASSWORD=sua_palavra_passe_root mysql-docker

Este comando define a variável de ambiente MYSQL_ROOT_PASSWORD. Pode definir várias variáveis de ambiente usando várias opções -e.

Montar Volumes para Dados Persistentes

Por predefinição, os dados armazenados num contentor Docker não são persistentes. Se o contentor for parado ou eliminado, os dados são perdidos. Para manter os dados, precisa de usar volumes Docker. Os volumes fornecem uma forma de armazenar dados fora do sistema de ficheiros do contentor.

Compreender os Volumes Docker

Os volumes Docker são diretórios na máquina anfitriã que são montados no contentor. As alterações efetuadas nos ficheiros dentro do volume são imediatamente refletidas na máquina anfitriã e vice-versa. Isto garante que os seus dados persistem mesmo que o contentor seja parado ou eliminado.

Criar um Volume

Pode criar um volume Docker usando o comando docker volume create:

docker volume create mysql-data

Este comando cria um volume com o nome mysql-data. O Docker irá gerir automaticamente a localização física do volume na máquina anfitriã.

Montar o Volume no Contentor

Para montar o volume no contentor, use a opção -v com o comando docker run:

docker run -d --name mysql-container -p 3306:3306 -e MYSQL_ROOT_PASSWORD=sua_palavra_passe_root -v mysql-data:/var/lib/mysql mysql-docker

Vamos analisar a opção -v:

  • -v mysql-data:/var/lib/mysql: Isto monta o volume mysql-data no diretório /var/lib/mysql dentro do contentor. /var/lib/mysql é o diretório predefinido onde o MySQL armazena os seus ficheiros de dados. Ao montar um volume neste diretório, garante que os seus dados MySQL são armazenados persistentemente na máquina anfitriã.

Agora, quaisquer dados escritos no diretório /var/lib/mysql dentro do contentor serão armazenados no volume mysql-data na máquina anfitriã. Isto garante que os seus dados persistem mesmo que pare ou elimine o contentor. Os dados persistentes são especialmente importantes para as bases de dados para evitar a perda de dados e manter a integridade dos dados.

Ao seguir estes passos, pode executar com sucesso o seu contentor MySQL com mapeamento de portas, variáveis de ambiente e armazenamento de dados persistentes. Isto fornece uma forma robusta e fiável de implementar o MySQL usando o Docker. Esta é uma melhor prática do Docker para gerir aplicações com estado.

Ligar ao Servidor MySQL

Agora que o seu contentor MySQL está em execução, vai querer ligar-se ao servidor MySQL para gerir as suas bases de dados. Esta secção aborda a ligação usando o cliente MySQL, a partir de uma máquina anfitriã e a partir de outro contentor, fornecendo um guia abrangente para aceder à sua instância MySQL Docker.

Usar o Cliente MySQL

O cliente MySQL é uma ferramenta de linha de comandos para interagir com servidores MySQL. Pode usá-lo para executar consultas SQL, gerir utilizadores e executar outras tarefas administrativas. Se o cliente MySQL ainda não estiver instalado no seu sistema, terá de o instalar. Eis como instalá-lo no Ubuntu/Debian e CentOS/RHEL:

Ubuntu/Debian

sudo apt updatesudo apt install mysql-client

CentOS/RHEL

sudo yum install mysql

Depois de o cliente MySQL estar instalado, pode ligar-se ao servidor MySQL em execução no seu contentor Docker usando o seguinte comando:

mysql -h 127.0.0.1 -P 3306 -u root -p

Vamos analisar este comando:

  • mysql: Este é o comando para iniciar o cliente MySQL.
  • -h 127.0.0.1: Isto especifica o nome do anfitrião ou o endereço IP do servidor MySQL. 127.0.0.1 (localhost) refere-se à sua máquina local. Se o seu servidor MySQL estiver em execução num anfitrião remoto, substitua isto pelo endereço IP ou nome do anfitrião apropriado.
  • -P 3306: Isto especifica o número da porta do servidor MySQL. A porta predefinida do MySQL é 3306. Se mapeou a porta do contentor para uma porta diferente na máquina anfitriã, use esse número de porta aqui.
  • -u root: Isto especifica o nome de utilizador a usar para se ligar ao servidor MySQL. Neste caso, estamos a usar o utilizador root. Também pode usar outros utilizadores se os tiver criado.
  • -p: Isto solicita que introduza a palavra-passe para o utilizador especificado. Quando executa o comando, o cliente irá pedir-lhe para escrever a palavra-passe. Não será apresentado no ecrã por razões de segurança.

Depois de introduzir a palavra-passe, deverá estar ligado ao servidor MySQL. Pode então executar consultas SQL e executar outras tarefas administrativas.

Ligar a partir de uma Máquina Anfitriã

Para ligar ao servidor MySQL a partir de uma máquina anfitriã, precisa de garantir que o mapeamento de portas está configurado corretamente. Se usou a opção -p 3306:3306 ao executar o contentor, pode ligar-se ao servidor MySQL usando localhost:3306.

Pode usar qualquer cliente ou aplicação MySQL para se ligar ao servidor. Basta especificar o nome do anfitrião como localhost ou 127.0.0.1, a porta como 3306 e o nome de utilizador e a palavra-passe apropriados.

Exemplo usando uma ferramenta GUI (p. ex., MySQL Workbench):

  • Nome do Anfitrião: 127.0.0.1
  • Porta: 3306
  • Nome de Utilizador: root
  • Palavra-Passe: sua_palavra_passe_root

Ligar a partir de Outro Contentor

Se tiver vários contentores Docker que precisam de comunicar entre si, pode ligar-se ao servidor MySQL a partir de outro contentor usando a rede Docker. Esta é uma forma mais segura e fiável de ligar contentores em comparação com expor portas diretamente para a máquina anfitriã.

Primeiro, precisa de criar uma rede Docker:

docker network create minha-rede

Em seguida, execute o contentor MySQL e o outro contentor nesta rede. Quando executar os contentores, adicione a opção --network minha-rede ao comando docker run.

Exemplo:

docker run -d --name mysql-container --network minha-rede -p 3306:3306 -e MYSQL_ROOT_PASSWORD=sua_palavra_passe_root -v mysql-data:/var/lib/mysql mysql-dockerdocker run -d --name outro-container --network minha-rede sua-outra-imagem

Agora, os contentores podem comunicar entre si usando os seus nomes de contentor como nomes de anfitrião. No outro-container, pode ligar-se ao servidor MySQL usando mysql-container como nome do anfitrião.

Exemplo de string de ligação de outro-container:

mysql -h mysql-container -P 3306 -u root -p

Esta abordagem, usando a rede Docker, é uma melhor prática do Docker para comunicação entre contentores. Fornece melhor isolamento e segurança em comparação com a exposição de portas para a máquina anfitriã. Compreender estes métodos para ligar ao seu criar contentor MySQL é fundamental para gerir e utilizar eficazmente a sua colocação em contentores da base de dados.

Casos de Uso Reais

Agora que aprendeu como criar um Dockerfile MySQL e executar um contentor MySQL, vamos explorar alguns casos de uso reais em que esta configuração pode ser incrivelmente benéfica. Estes casos de uso destacam a flexibilidade e a eficiência do uso do Docker para a colocação em contentores de bases de dados e a implementação MySQL.

Ambiente de Desenvolvimento

Usar o Docker para o seu ambiente de desenvolvimento garante consistência em diferentes máquinas de programadores. Imagine um cenário em que os membros da sua equipa têm diferentes sistemas operativos, versões de bibliotecas ou até mesmo instalações de software conflitantes. O Docker resolve este problema fornecendo um ambiente padronizado para todos.

Benefícios:

  • Consistência: Todos os programadores trabalham com a mesma versão e configuração do MySQL, eliminando os problemas de “funciona na minha máquina”.
  • Isolamento: Cada projeto pode ter a sua própria instância MySQL isolada, evitando conflitos entre projetos.
  • Configuração Fácil: Os novos programadores podem configurar rapidamente o seu ambiente de desenvolvimento simplesmente executando um comando Docker, em vez de instalar e configurar manualmente o MySQL.
  • Reprodutibilidade: O Dockerfile atua como documentação para o ambiente, facilitando a reprodução do ambiente em qualquer máquina.

Exemplo de Fluxo de Trabalho:

  1. Um programador clona o repositório do projeto.
  2. O programador executa docker-compose up (se estiver a usar o Docker Compose) ou docker run com as opções apropriadas para iniciar o contentor MySQL.
  3. O programador liga-se ao servidor MySQL usando o seu cliente MySQL preferido e começa a trabalhar no projeto.

Integração Contínua/Implementação Contínua (CI/CD)

O Docker é uma solução natural para pipelines CI/CD. Permite-lhe criar facilmente ambientes consistentes e isolados para executar testes automatizados e implementar a sua aplicação.

Benefícios:

  • Testes Automatizados: Pode iniciar automaticamente um contentor MySQL como parte do seu pipeline CI/CD para executar testes de integração numa instância de base de dados nova.
  • Implementação Consistente: O Docker garante que a sua aplicação e as suas dependências, incluindo o MySQL, são implementadas de forma consistente em diferentes ambientes (p. ex., desenvolvimento, teste, produção).
  • Rollbacks: Se uma implementação falhar, pode facilmente reverter para uma versão anterior simplesmente alternando para uma imagem Docker diferente.

Exemplo de Pipeline CI/CD (usando Jenkins):

  1. Um programador submete código para o repositório.
  2. O Jenkins constrói automaticamente uma nova imagem Docker que contém a aplicação e as suas dependências.
  3. O Jenkins inicia um contentor MySQL usando o Dockerfile e executa testes de integração no mesmo.
  4. Se os testes forem aprovados, o Jenkins envia a nova imagem Docker para um registo (p. ex., Docker Hub).
  5. O Jenkins implementa a nova imagem Docker no ambiente de produção.

Implementação em Produção

Usar o Docker para implementações em produção fornece inúmeros benefícios, incluindo escalabilidade, portabilidade e isolamento.

Benefícios:

  • Escalabilidade: Pode facilmente dimensionar a sua implementação MySQL executando vários contentores por detrás de um balanceador de carga.
  • Portabilidade: Os contentores Docker podem ser executados em qualquer plataforma que suporte o Docker, facilitando a movimentação da sua aplicação entre diferentes fornecedores de nuvem ou ambientes no local.
  • Isolamento: Os contentores Docker fornecem isolamento de processos e do sistema de ficheiros, evitando que as aplicações interfiram umas com as outras. Isto melhora a segurança e a estabilidade.
  • Eficiência de Recursos: Os contentores Docker são leves e consomem menos recursos do que as máquinas virtuais tradicionais, permitindo-lhe executar mais aplicações no mesmo hardware.

Exemplo de Implementação em Produção (usando Docker Swarm ou Kubernetes):

  1. Crie um cluster Docker Swarm ou um cluster Kubernetes.
  2. Defina um serviço para o seu contentor MySQL, especificando a imagem Docker, mapeamentos de portas e outras opções de configuração.
  3. Implemente o serviço no cluster.
  4. O cluster gere automaticamente a implementação, garantindo que o número desejado de contentores MySQL está em execução e que estão devidamente equilibrados em termos de carga.

Estes casos de uso reais demonstram o poder e a versatilidade do uso do Docker para a implementação MySQL. Quer esteja a desenvolver uma pequena aplicação ou a gerir um ambiente de produção em grande escala, o Docker pode ajudá-lo a otimizar o seu fluxo de trabalho, melhorar a consistência e aumentar a segurança. Compreender estes cenários ajuda a otimizar as aplicações e os benefícios da colocação em contentores do MySQL.

Comandos Explicados

Esta seção fornece uma explicação detalhada dos comandos do Dockerfile usados nos capítulos anteriores. Compreender estes comandos é crucial para criar Dockerfiles eficazes e otimizados para MySQL e outras aplicações. Este conhecimento é vital para implementar melhores práticas do Docker.

FROM

Definir a Imagem Base

A instrução FROM define a imagem base para instruções subsequentes. É a base da sua imagem Docker. Sem uma instrução FROM, não está a construir sobre uma imagem existente, potencialmente otimizada. Especifica a imagem principal a partir da qual a sua imagem é construída.

FROM mysql:8.0

Opções e Detalhes:

  • nome_da_imagem:etiqueta: Especifica o nome da imagem e a etiqueta. A etiqueta é opcional; se for omitida, latest é assumido. Usar etiquetas específicas (p. ex., 8.0.32) é recomendado para reprodutibilidade.

ENV

Definir Variáveis de Ambiente

A instrução ENV define variáveis de ambiente dentro do contentor. Estas variáveis podem ser usadas pelo servidor MySQL ou outras aplicações em execução dentro do contentor. Fornecem uma forma de configurar as suas aplicações dinamicamente.

ENV MYSQL_ROOT_PASSWORD=sua_palavra_passe_root

Opções e Detalhes:

  • nome_da_variável: O nome da variável de ambiente.
  • valor_da_variável: O valor da variável de ambiente.

É importante notar que, embora ENV seja conveniente, não é a forma mais segura de lidar com dados confidenciais como palavras-passe em produção. Considere usar segredos do Docker ou outros métodos seguros para gerir credenciais.

EXPOSE

Expor Portas

A instrução EXPOSE informa o Docker que o contentor está à escuta nas portas de rede especificadas em tempo de execução. Não publica realmente a porta, mas serve como documentação e é usada pelo Docker durante o mapeamento de portas.

EXPOSE 3306

Opções e Detalhes:

  • número_da_porta: O número da porta que o contentor está à escuta.

Para realmente publicar a porta na máquina anfitriã, precisa de usar a opção -p com o comando docker run. Isto cria um mapeamento entre a porta do anfitrião e a porta do contentor.

COPY

Copiar Ficheiros para o Contentor

A instrução COPY copia novos ficheiros ou diretórios do contexto de construção para o sistema de ficheiros do contentor.

COPY my.cnf /etc/mysql/conf.d/my.cnf

Opções e Detalhes:

  • origem: O caminho para o ficheiro ou diretório na máquina anfitriã (relativo ao contexto de construção).
  • destino: O caminho para a localização dentro do contentor onde o ficheiro ou diretório deve ser copiado.

A instrução COPY é útil para adicionar ficheiros de configuração, scripts ou outros recursos ao seu contentor.

ENTRYPOINT

Definir o Ponto de Entrada

A instrução ENTRYPOINT especifica o comando que será executado quando o contentor é iniciado. Define o processo principal que é executado dentro do contentor.

ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]

Opções e Detalhes:

  • executável: O comando ou script a ser executado.

A instrução ENTRYPOINT pode ser usada em duas formas: forma exec (como mostrado acima) e forma shell. A forma exec é preferida porque evita processos shell desnecessários.

docker build

Construir a Imagem Docker

O comando docker build constrói uma imagem Docker a partir de um Dockerfile. Lê as instruções no Dockerfile e executa-as em sequência para criar a imagem.

docker build -t mysql-docker .

Opções e Detalhes:

  • -t nome_da_imagem:etiqueta: Atribui uma etiqueta (nome) à imagem.
  • .: Especifica o contexto de construção (o diretório que contém o Dockerfile e outros ficheiros).

docker run

Executar o Contentor

O comando docker run cria e inicia um contentor a partir de uma imagem Docker. É o comando que traz a sua imagem Docker à vida.

docker run -d --name mysql-container -p 3306:3306 -e MYSQL_ROOT_PASSWORD=sua_palavra_passe_root -v mysql-data:/var/lib/mysql mysql-docker

Opções e Detalhes:

  • -d: Executa o contentor em modo destacado (em segundo plano).
  • --name nome_do_contentor: Atribui um nome ao contentor.
  • -p porta_do_anfitrião:porta_do_contentor: Mapeia uma porta na máquina anfitriã para uma porta no contentor.
  • -e nome_da_variável=valor_da_variável: Define uma variável de ambiente dentro do contentor.
  • -v volume_do_anfitrião:caminho_do_contentor: Monta um volume da máquina anfitriã para um caminho dentro do contentor.
  • nome_da_imagem: O nome da imagem Docker a executar.

Compreender estes comandos e as suas opções é crucial para dominar o Docker e criar um contentor MySQL eficazmente. Esta explicação detalhada promove melhores práticas do Docker e contribui para estratégias melhoradas de colocação em contentores da base de dados.

Detalhes da Configuração

Esta seção aborda os detalhes da configuração do seu contentor MySQL Docker, focando no ficheiro de configuração do MySQL (my.cnf) e na configuração do volume Docker. A configuração adequada é crucial para otimizar o desempenho, garantir a persistência dos dados e manter a segurança. Estes detalhes são essenciais para aderir às melhores práticas do Docker e alcançar uma colocação em contentores da base de dados eficaz.

Ficheiro de Configuração do MySQL (my.cnf)

O ficheiro my.cnf é o ficheiro de configuração principal para o MySQL. Controla vários aspetos do servidor MySQL, incluindo tamanhos de buffer, conjuntos de caracteres, registo e definições de segurança. Personalizar este ficheiro permite ajustar o MySQL para atender às necessidades específicas da sua aplicação. Isto irá ajudá-lo a criar um contentor MySQL com configurações ideais.

Opções de Configuração Principais:

  • innodb_buffer_pool_size: Esta opção determina o tamanho do pool de buffer InnoDB, que é usado para colocar dados e índices em cache. Um pool de buffer maior pode melhorar o desempenho, especialmente para cargas de trabalho com muita leitura. Uma recomendação comum é definir isso para 50-80% da RAM disponível, mas sempre monitorize o uso de memória do seu sistema.
[mysqld]innodb_buffer_pool_size=2G
  • character-set-server e collation-server: Estas opções definem o conjunto de caracteres predefinido e a ordenação para o servidor MySQL. Definir estes para utf8mb4 e utf8mb4_unicode_ci, respetivamente, suporta uma ampla gama de caracteres, incluindo emojis.
[mysqld]character-set-server=utf8mb4collation-server=utf8mb4_unicode_ci
  • max_connections: Esta opção limita o número de ligações simultâneas ao servidor MySQL. Definir isto muito baixo pode levar a erros de ligação, enquanto definir muito alto pode consumir recursos excessivos.
[mysqld]max_connections=500
  • log_error: Esta opção especifica o caminho para o registo de erros do MySQL. Monitorizar este registo é essencial para resolver problemas.
[mysqld]log_error=/var/log/mysql/error.log
  • sql_mode: Esta opção controla os modos SQL que o MySQL usa para validar dados. Definir um modo SQL estrito pode ajudar a evitar a corrupção de dados e melhorar a integridade dos dados.
[mysqld]sql_mode=STRICT_TRANS_TABLES,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION

Aplicar Configuração Personalizada:

  1. Crie um ficheiro my.cnf com as opções de configuração desejadas.
    1. Copie o ficheiro my.cnf para o diretório /etc/mysql/conf.d/ dentro do contentor usando a instrução COPY no seu Dockerfile:
COPY my.cnf /etc/mysql/conf.d/my.cnf
  1. Reinicie o servidor MySQL para que as alterações entrem em vigor. A imagem oficial do MySQL Docker normalmente lida com isso automaticamente ao iniciar o contentor se o ficheiro de configuração estiver presente.

Considerações Importantes:

  • Segurança: Evite incluir informações confidenciais, como palavras-passe, diretamente no ficheiro my.cnf. Use variáveis de ambiente ou segredos do Docker.
  • Teste de Desempenho: Teste as suas alterações de configuração cuidadosamente para garantir que melhoram o desempenho sem introduzir instabilidade.
  • Documentação: Documente as suas alterações de configuração claramente, explicando o objetivo de cada opção e o seu impacto potencial.

Configuração do Volume Docker

Os volumes Docker fornecem armazenamento persistente para os seus dados MySQL. Usar volumes garante que os seus dados sobrevivem mesmo que o contentor seja parado, eliminado ou recriado. A configuração adequada do volume é crucial para a durabilidade e capacidade de recuperação dos dados. Isto está alinhado com as melhores práticas de implementação MySQL.

Tipos de Volumes:

  • Volumes Nomeados: Estes volumes são criados e geridos pelo Docker. Têm um nome e são armazenados num local gerido pelo Docker.
  • Montagens de Ligação: Estes volumes montam um diretório ou ficheiro da máquina anfitriã diretamente no contentor. Fornecem mais flexibilidade, mas são menos portáteis do que volumes nomeados.

Usar Volumes Nomeados (Recomendado):

  1. Crie um volume nomeado:
docker volume create mysql-data
  1. Monte o volume no diretório /var/lib/mysql dentro do contentor usando a opção -v com o comando docker run:
docker run -d -v mysql-data:/var/lib/mysql ... mysql-docker

Usar Montagens de Ligação (Menos Recomendado para Produção):

  1. Crie um diretório na máquina anfitriã para armazenar os dados do MySQL:
mkdir /caminho/para/mysql-data
  1. Monte o diretório no diretório /var/lib/mysql dentro do contentor usando a opção -v com o comando docker run:
docker run -d -v /caminho/para/mysql-data:/var/lib/mysql ... mysql-docker

Considerações Importantes:

  • Permissões: Certifique-se de que o utilizador MySQL dentro do contentor tem as permissões corretas para ler e escrever no volume. A imagem oficial do MySQL Docker normalmente lida com isso automaticamente, mas pode precisar de ajustar as permissões se estiver a usar uma imagem personalizada ou uma montagem de ligação.
  • Backup e Recuperação: Implemente uma estratégia regular de backup e recuperação para os seus dados MySQL. Pode usar ferramentas como mysqldump ou mysqlpump para criar backups dos seus dados e armazená-los num local seguro.
  • Localização do Volume: Esteja ciente da localização física dos seus volumes Docker. A localização predefinida varia dependendo do seu sistema operativo e da configuração do Docker. Compreender a localização é importante para a resolução de problemas e a recuperação de desastres.

Ao configurar cuidadosamente o seu contentor MySQL Docker usando um ficheiro my.cnf personalizado e volumes Docker, pode otimizar o desempenho, garantir a persistência dos dados e manter a segurança. Esta abordagem abrangente é essencial para executar o MySQL num ambiente em contentores de forma eficaz.

Resolução de Problemas

Mesmo com um planeamento cuidadoso, poderá encontrar problemas ao construir ou executar o seu contentor MySQL Docker. Esta secção fornece orientação sobre a resolução de problemas comuns e oferece dicas úteis de depuração para garantir uma experiência tranquila. Abordar estes desafios de forma eficaz é crucial para manter as melhores práticas do Docker e alcançar uma colocação em contentores da base de dados bem-sucedida.

Erros Comuns

Eis alguns erros comuns que pode encontrar e como resolvê-los:

Imagem Não Encontrada

Este erro ocorre quando o Docker não consegue encontrar a imagem base especificada.

Solução: Verifique novamente o nome da imagem e a etiqueta no seu Dockerfile. Certifique-se de que a imagem está disponível no Docker Hub ou num registo privado ao qual tem acesso. Se estiver a usar um registo privado, certifique-se de que iniciou a sessão.

FROM mysql:8.0

Porta Já em Uso

Este erro ocorre quando tenta mapear uma porta que já está em uso na sua máquina anfitriã.

Solução: Escolha uma porta diferente para mapeamento ou pare o processo que está atualmente a usar a porta. Pode usar o comando netstat ou ss para identificar o processo que está a usar a porta.

docker run -p 3306:3306 ...

Variáveis de Ambiente Incorretas

Este erro pode ocorrer se as variáveis de ambiente não estiverem definidas corretamente, levando o MySQL a não inicializar corretamente.

Solução: Verifique se definiu todas as variáveis de ambiente necessárias, como MYSQL_ROOT_PASSWORD. Certifique-se de que os valores estão corretos e atendem aos requisitos do MySQL. Para produção, evite codificar valores confidenciais diretamente no Dockerfile; use segredos do Docker ou configuração externa.

docker run -e MYSQL_ROOT_PASSWORD=sua_palavra_passe_root ...

Problemas de Montagem de Volume

Problemas com montagens de volume podem causar problemas de persistência de dados ou impedir o início do MySQL.

Solução: Verifique se o volume existe e se o utilizador MySQL dentro do contentor tem as permissões corretas para ler e escrever no volume. Se estiver a usar montagens de ligação, certifique-se de que o diretório anfitrião existe e está acessível.

docker run -v mysql-data:/var/lib/mysql ...

Erros no Ficheiro de Configuração

Erros de sintaxe ou definições incorretas no ficheiro my.cnf podem impedir o início do MySQL ou causar um comportamento inesperado.

Solução: Valide o seu ficheiro my.cnf usando um validador de configuração MySQL ou executando o MySQL com a opção --validate-config. Verifique o registo de erros do MySQL para obter detalhes sobre o erro específico.

COPY my.cnf /etc/mysql/conf.d/my.cnf

Dicas de Depuração

Eis algumas dicas para depurar o seu contentor MySQL Docker:

  • Verificar Registos do Contentor: Use o comando docker logs para ver a saída do contentor. Isto pode fornecer informações valiosas sobre erros ou avisos que estão a ocorrer.
docker logs mysql-container
  • Inspecionar o Contentor: Use o comando docker inspect para ver a configuração do contentor, incluindo variáveis de ambiente, mapeamentos de portas e montagens de volume.
docker inspect mysql-container
  • Executar Comandos Dentro do Contentor: Use o comando docker exec para executar comandos dentro do contentor. Isto permite-lhe resolver problemas diretamente dentro do ambiente do contentor.
docker exec -it mysql-container bash
  • Usar uma Imagem de Depuração: Crie uma imagem Docker separada com ferramentas de depuração instaladas, como strace ou tcpdump. Pode então executar esta imagem juntamente com o seu contentor MySQL para monitorizar o seu comportamento.
  • Simplificar o Seu Dockerfile: Se estiver a encontrar problemas complexos, tente simplificar o seu Dockerfile para isolar o problema. Comente ou remova instruções desnecessárias e reconstrua a imagem para ver se o problema persiste.
  • Consultar o Registo de Erros do MySQL: O registo de erros do MySQL contém informações detalhadas sobre erros e avisos. Verifique este registo regularmente para obter informações sobre potenciais problemas. A localização do registo de erros é normalmente /var/log/mysql/error.log dentro do contentor.

Ao seguir estas dicas de resolução de problemas e ao abordar erros comuns, pode depurar eficazmente o seu contentor MySQL Docker e garantir uma implementação estável e fiável.

Conclusão

Criar um Dockerfile MySQL é uma forma poderosa de otimizar os seus fluxos de trabalho de desenvolvimento, teste e implementação. Ao seguir os passos descritos neste guia, pode construir uma imagem MySQL personalizada que atenda às suas necessidades específicas, garantindo consistência e portabilidade em diferentes ambientes. Desde a compreensão dos conceitos básicos do Docker até à configuração de armazenamento persistente e à resolução de problemas comuns, agora possui o conhecimento para colocar eficazmente a sua base de dados MySQL em contentores. Adotar o Docker para a colocação em contentores da base de dados não só simplifica a implementação do MySQL, mas também promove melhores práticas do Docker. Esta abordagem simplifica a criação de contentores MySQL e a gestão eficiente de implementações MySQL Docker. Com estas competências, está bem equipado para tirar partido dos benefícios do Docker para as suas aplicações MySQL.

Pode fazer uma doação para ajudar a mater o site, Obrigado!