Uma introdução à implantação do MySQL usando uma função Ansible

O Ansible automatiza e simplifica operações repetitivas, complexas e tediosas. É um mecanismo de automação de TI que automatiza o provisionamento de nuvem, gerenciamento de configuração, implantação de aplicativos, orquestração intra-serviço e muitas outras necessidades de TI. Ele não requer agentes, usando apenas SSH para enviar alterações de uma única fonte para vários recursos remotos sem configuração de infraestrutura de segurança personalizada adicional e usa um formato de linguagem simples (YAML) para descrever os trabalhos de automação.

Instalar um servidor MySQL autônomo é uma tarefa simples e direta, mas isso pode ser problemático se você tiver vários servidores de banco de dados, versões, plataformas e ambientes para suportar. Assim, ter uma ferramenta de gerenciamento de configuração é o caminho a percorrer para melhorar a eficiência, eliminar a repetitividade e reduzir os erros humanos.

Nesta postagem do blog, vamos orientá-lo no básico da automação do Ansible para MySQL, bem como no gerenciamento de configuração com exemplos e explicações. Começaremos com uma implantação simples e autônoma do MySQL, conforme ilustrado no diagrama de alto nível a seguir:

Instalando o Ansible

Para este passo a passo, precisamos ter pelo menos dois hosts - um host é para o Ansible (você pode usar uma estação de trabalho em vez de um servidor) e outro é o host de destino que queremos implantar servidor MySQL.

Para instalar o Ansible no CentOS 7, basta executar os seguintes comandos:

(ansible-host)$ yum install -y epel-release

(ansible-host)$ yum install -y ansible

Para outras distribuições de SO, confira o guia de instalação do Ansible.

Configurando SSH sem senha

O uso de senha durante o SSH é suportado, mas as chaves SSH sem senha com ssh-agent são uma das melhores maneiras de usar o Ansible. A etapa inicial é configurar o SSH sem senha, pois o Ansible realizará a implantação exclusivamente por esse canal. Primeiramente, gere uma chave SSH no host Ansible:

(ansible-host)$ whoami

root

(ansible-host)$ ssh-keygen -t rsa -N '' -f ~/.ssh/id_rsa

Você deve obter pelo menos os seguintes arquivos gerados:

(ansible-host)$ ls -al ~/.ssh/

-rw-------. 1 root root 1679 Jan 14 03:40 id_rsa

-rw-r--r--. 1 root root  392 Jan 14 03:40 id_rsa.pub

Para permitir SSH sem senha, precisamos copiar a chave pública SSH (id_rsa.pub) para o host remoto que desejamos acessar. Podemos usar uma ferramenta chamada ssh-copy-id para fazer essa tarefa para nós. No entanto, você deve saber a senha do usuário do host de destino e a autenticação de senha é permitida no host de destino:

(ansible-host)$ whoami

root

(ansible-host)$ ssh-copy-id [email protected]

O comando acima solicitará a senha root de 192.168.0.221, basta digitar a senha e a chave SSH para o usuário atual do host Ansible será copiada para o host de destino, 192.168.0.221 em ~/.ssh/authorized_keys, o que significa que autorizamos essa chave específica a acessar este servidor remotamente. Para testar, você deve poder executar o seguinte comando remoto sem nenhuma senha do host Ansible:

(ansible-host)$ ssh [email protected] "hostname -I"

192.168.0.221

No caso em que você não tem permissão para usar o usuário root para SSH (por exemplo, "PermitRootLogin no" na configuração SSH), você pode usar um usuário sudo. No exemplo a seguir, configuramos o SSH sem senha para um usuário sudo chamado "vagrant":

(ansible-host)$ whoami

vagrant

(ansible-host)$ ssh-keygen -t rsa -N '' -f ~/.ssh/id_rsa

(ansible-host)$ ls -al ~/.ssh/

-rw-------. 1 vagrant vagrant 1679 Jan 14 03:45 id_rsa

-rw-r--r--. 1 vagrant vagrant  392 Jan 14 03:45 id_rsa.pub

(ansible-host)$ ssh-copy-id [email protected]

Se o servidor de destino não permitir autenticação de senha via SSH, basta copiar o conteúdo da chave pública SSH em ~/.ssh/id_rsa.pub manualmente no ~/.ssh/authorized_keys dos hosts de destino Arquivo. Por exemplo, no host Ansible, recupere o conteúdo da chave pública:

(ansible-host)$ cat ~/.ssh/id_rsa.pub

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC5MZjufN0OiKyKa2OG0EPBEF/w23FnOG2x8qpAaYYuqHlVc+ZyRugtGm+TdTJDfLA1Sr/rtZpXmPDuLUdlAvPmmwqIhgiatKiDw5t2adNUwME0sVgAlBv/KvbusTTdtpFQ1o+Z9CltGiENDCFytr2nVeBFxImoZu2H0ilZed/1OY2SZejUviXTQ0Dh0QYdIeiQHkMf1CiV2sNYs8j8+ULV26OOKCd8c1h1O9M5Dr4P6kt8E1lVSl9hbd4EOHQmeZ3R3va5zMesLk1A+iadIGJCJNCVOA2RpxDHmmaX28zQCwrpCliH00g9iCRixlK+cB39d1coUWVGy7SeaI8bzfv3 [email protected]

Conecte-se ao host de destino e cole a chave pública do host do Ansible em ~/.ssh/authorized_keys:

(target-host)$ whoami

root

(target-host)$ vi ~/.ssh/authorized_keys

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC5MZjufN0OiKyKa2OG0EPBEF/w23FnOG2x8qpAaYYuqHlVc+ZyRugtGm+TdTJDfLA1Sr/rtZpXmPDuLUdlAvPmmwqIhgiatKiDw5t2adNUwME0sVgAlBv/KvbusTTdtpFQ1o+Z9CltGiENDCFytr2nVeBFxImoZu2H0ilZed/1OY2SZejUviXTQ0Dh0QYdIeiQHkMf1CiV2sNYs8j8+ULV26OOKCd8c1h1O9M5Dr4P6kt8E1lVSl9hbd4EOHQmeZ3R3va5zMesLk1A+iadIGJCJNCVOA2RpxDHmmaX28zQCwrpCliH00g9iCRixlK+cB39d1coUWVGy7SeaI8bzfv3 [email protected]

Agora você pode tentar executar um comando remoto do host Ansible para verificar e não deverá ser solicitada nenhuma senha. Neste ponto, nosso SSH sem senha está configurado.

Definindo o host de destino

Em seguida, precisamos definir o host de destino, o host que queremos gerenciar usando o Ansible. Com base em nossa arquitetura, vamos implantar apenas um servidor MySQL que é 192.168.0.221. Adicione as seguintes linhas em /etc/ansible/hosts:

[db-mysql]

192.168.0.221

O acima significa simplesmente que definimos um grupo chamado "db-mysql", que será o identificador quando nos referirmos ao host de destino no manual do Ansible. Também podemos listar todos os endereços IP ou nomes de host dos hosts de destino neste grupo. Neste ponto, temos apenas um servidor MySQL para implantar, portanto, apenas uma entrada está lá. Você também pode especificar qualquer regra de correspondência para corresponder aos hosts em um grupo, por exemplo:

[db-mysql]

192.168.0.[221:223]

A definição acima significa que temos 3 hosts neste mesmo grupo com os seguintes endereços IP:

• 192.168.0.221
• 192.168.0.222
• 192.168.0.223

Escolhendo uma função Ansible

Para dizer ao Ansible o que implantar, precisamos definir as etapas de implantação em um arquivo formatado em YML chamado playbook. Como você deve saber, a instalação de um servidor MySQL completo requer várias etapas para satisfazer todas as dependências do MySQL, configuração pós-instalação, criação de usuário e esquema e assim por diante. O Ansible forneceu vários módulos MySQL que podem nos ajudar, mas ainda temos que escrever um manual para as etapas de implantação.

Para simplificar as etapas de implantação, podemos usar as funções existentes do Ansible. A função Ansible é um componente independente que permite a reutilização de etapas comuns de configuração. Uma função Ansible deve ser usada no manual. Há várias funções do MySQL Ansible disponíveis no Ansible Galaxy, um repositório para funções do Ansible que estão disponíveis para serem colocadas diretamente em seus playbooks.

Se você pesquisar "mysql", obterá várias funções do Ansible para MySQL:

Usaremos o mais popular chamado "mysql" por geerlingguy. Você pode optar por usar outras funções, mas principalmente a mais baixada tende a ser para fins gerais, o que geralmente funciona bem na maioria dos casos.

No host do Ansible, execute o seguinte comando para baixar a função do Ansible:

(ansible-host)$ ansible-galaxy install geerlingguy.mysql

A função será baixada em ~/.ansible/roles/geerlingguy.mysql/ do usuário atual.

Escrevendo o manual do Ansible

Ao observar o Leiame da função Ansible, podemos seguir o exemplo de manual que está sendo fornecido. Primeiro, crie um arquivo de playbook chamado deploy-mysql.yml e adicione as seguintes linhas:

(ansible-host)$ vim ~/deploy-mysql.yml

- hosts: db-mysql

  become: yes

  vars_files:

    - vars/main.yml

  roles:

    - { role: geerlingguy.mysql }

Nas linhas acima, definimos o host de destino que são todos os hosts sob as entradas db-mysql em /etc/ansible/hosts. A próxima linha (become) diz ao Ansible para executar o playbook como usuário root, o que é necessário para a função (é declarado lá no arquivo Leiame). Em seguida, definimos a localização do arquivo de variáveis ​​(var_files) localizado em vars/main.yml, relativo ao caminho do playbook.

Vamos criar o diretório e o arquivo de variáveis ​​e especificar a seguinte linha:

(ansible-host)$ mkdir vars

(ansible-host)$ vim vars/main.yml

mysql_root_password: "theR00tP455w0rd"

Para obter mais informações, confira a seção Variáveis ​​de função no arquivo Leiame desta função.

Iniciar a implantação

Agora estamos prontos para iniciar a implantação do MySQL. Use o comando ansible-playbook para executar nossas definições de playbook:

(ansible-host)$ ansible-playbook deploy-mysql.yml

Você deve ver um monte de linhas aparecerem na saída. Concentre-se na última linha onde ela resume a implantação:

PLAY RECAP ***************************************************************************************************************************************

192.168.0.221              : ok=36 changed=8 unreachable=0    failed=0 skipped=16 rescued=0 ignored=0

Se tudo ficar verde e OK, você pode verificar no host do banco de dados se nosso servidor MySQL já está instalado e funcionando:

(mysql-host)$ rpm -qa | grep -i maria

mariadb-server-5.5.64-1.el7.x86_64

mariadb-libs-5.5.64-1.el7.x86_64

mariadb-5.5.64-1.el7.x86_64



(mysql-host)$ mysqladmin -uroot -p ping

Enter password:

mysqld is alive

Como você pode ver acima, para o CentOS 7, a instalação padrão do MySQL é o MariaDB 5.5 como parte do repositório de pacotes padrão. Neste ponto, nossa implantação é considerada concluída, no entanto, gostaríamos de personalizar ainda mais nossa implantação, conforme mostrado nas próximas seções.

Personalizando a implantação

A definição mais simples no playbook nos dá uma instalação muito básica e usa todas as opções de configuração padrão. Podemos personalizar ainda mais a instalação do MySQL estendendo/modificando/anexando o manual para fazer o seguinte:

• modificar as opções de configuração do MySQL
• adicionar usuário do banco de dados
• adicionar esquema de banco de dados
• configurar privilégios de usuário
• configurar a replicação do MySQL
• instale o MySQL de outros fornecedores
• importar um arquivo de configuração MySQL personalizado

Instalando o MySQL do repositório Oracle

Por padrão, a função instalará o pacote MySQL padrão que vem com a distribuição do SO. Quanto ao CentOS 7, você teria o MariaDB 5.5 instalado por padrão. Suponha que queremos instalar o MySQL de outro fornecedor, podemos estender o playbook com pre_tasks, uma tarefa que o Ansible executa antes de executar qualquer tarefa mencionada em qualquer arquivo .yml, conforme mostrado no exemplo a seguir:

(ansible-host)$ vim deploy-mysql.yml

- hosts: db-mysql

  become: yes

  vars_files:

    - vars/main.yml

  roles:

    - { role: geerlingguy.mysql }

  pre_tasks:

    - name: Install the MySQL repo.

      yum:

        name: http://repo.mysql.com/mysql-community-release-el7-5.noarch.rpm

        state: present

      when: ansible_os_family == "RedHat"

    - name: Override variables for MySQL (RedHat).

      set_fact:

        mysql_daemon: mysqld

        mysql_packages: ['mysql-server']

        mysql_log_error: /var/lib/mysql/error.log

        mysql_syslog_tag: mysqld

        mysql_pid_file: /var/run/mysqld/mysqld.pid

        mysql_socket: /var/lib/mysql/mysql.sock

      when: ansible_os_family == "RedHat"

Execute o manual:

(ansible-host)$ ansible-playbook deploy-mysql.yml

O acima instalará o MySQL do repositório Oracle. A versão padrão que você obteria é o MySQL 5.6. A execução do manual acima em um host de destino que já possui uma versão mais antiga do MySQL/MariaDB em execução provavelmente falharia devido à incompatibilidade.

Criando bancos de dados e usuários MySQL

Dentro de vars/main.yml, podemos definir o banco de dados MySQL e os usuários que queremos que o Ansible configure em nosso servidor MySQL usando os módulos mysql_database e mysql_users, logo após nossa definição anterior em mysql_root_password:

(ansible-host)$ vim vars/main.yml

mysql_root_password: "theR00tP455w0rd"

mysql_databases:

  - name: myshop

    encoding: latin1

    collation: latin1_general_ci

  - name: sysbench

    encoding: latin1

    collation: latin1_general_ci

mysql_users:

  - name: myshop_user

    host: "%"

    password: mySh0pPassw0rd

    priv: "myshop.*:ALL"

  - name: sysbench_user

    host: "192.168.0.%"

    password: sysBenchPassw0rd

    priv: "sysbench.*:ALL"

A definição instrui o Ansible a criar dois bancos de dados, "myshop" e "sysbench", seguidos de seu respectivo usuário MySQL com privilégios apropriados, host e senha permitidos.

Reexecute o playbook para aplicar a mudança em nosso servidor MySQL:

(ansible-host)$ ansible-playbook deploy-mysql.yml

Desta vez, o Ansible pegará todas as alterações que fizemos em vars/main.yml para serem aplicadas ao nosso servidor MySQL. Podemos verificar no servidor MySQL com os seguintes comandos:

(mysql-host)$ mysql -uroot -p -e 'SHOW DATABASES'

Enter password:

+--------------------+

| Database           |

+--------------------+

| information_schema |

| myshop             |

| mysql              |

| performance_schema |

| sysbench           |

+--------------------+

(mysql-host)$ mysql -uroot -p -e 'SHOW GRANTS FOR [email protected]"192.168.0.%"'

Enter password:

+------------------------------------------------------------------------------------------------------------------------+

| Grants for [email protected]%                                                                                   |

+------------------------------------------------------------------------------------------------------------------------+

| GRANT USAGE ON *.* TO 'sysbench_user'@'192.168.0.%' IDENTIFIED BY PASSWORD '*4AC2E8AD02562E8FAAF5A958DC2AEA4C47451B5C' |

| GRANT ALL PRIVILEGES ON `sysbench`.* TO 'sysbench_user'@'192.168.0.%'                                                  |

+------------------------------------------------------------------------------------------------------------------------+

Ativando o registro de consultas lentas

Esta função suporta a ativação do log de consulta lenta do MySQL, podemos definir a localização do arquivo de log, bem como o tempo de consulta lenta. Adicione as variáveis ​​necessárias dentro do arquivo vars/main.yml:

mysql_root_password: "theR00tP455w0rd"

mysql_databases:

  - name: example_db

    encoding: latin1

    collation: latin1_general_ci

  - name: sysbench

    encoding: latin1

    collation: latin1_general_ci

mysql_users:

  - name: example_user

    host: "%"

    password: similarly-secure-password

    priv: "example_db.*:ALL"

  - name: sysbench_user

    host: "192.168.0.%"

    password: sysBenchPassw0rd

    priv: "sysbench.*:ALL"

mysql_slow_query_log_enabled: true

mysql_slow_query_log_file: 'slow_query.log'

mysql_slow_query_time: '5.000000'

Execute novamente o manual para aplicar as alterações:

(ansible-host)$ ansible-playbook deploy-mysql.yml

O manual fará as alterações necessárias nas opções relacionadas à consulta lenta do MySQL e reiniciará o servidor MySQL automaticamente para carregar as novas configurações. Podemos então verificar se as novas opções de configuração estão carregadas corretamente no servidor MySQL:

(mysql-host)$ mysql -uroot -p -e 'SELECT @@slow_query_log, @@slow_query_log_file, @@long_query_time'

+------------------+-----------------------+-------------------+

| @@slow_query_log | @@slow_query_log_file | @@long_query_time |

+------------------+-----------------------+-------------------+

|                1 | slow_query.log        | 5.000000 |

+------------------+-----------------------+-------------------+

Incluindo arquivo de configuração MySQL personalizado

Variáveis ​​de função Ansible e variáveis ​​MySQL são duas coisas diferentes. O autor dessa função criou várias variáveis ​​relacionadas ao MySQL que podem ser representadas com variáveis ​​de função do Ansible. Extraído do arquivo Leiame, aqui estão alguns deles:

mysql_port: "3306"

mysql_bind_address: '0.0.0.0'

mysql_datadir: /var/lib/mysql

mysql_socket: *default value depends on OS*

mysql_pid_file: *default value depends on OS*

mysql_log_file_group: mysql *adm on Debian*

mysql_log: ""

mysql_log_error: *default value depends on OS*

mysql_syslog_tag: *default value depends on OS*

Se a configuração gerada não satisfizer nosso requisito MySQL, podemos incluir arquivos de configuração MySQL personalizados na implantação usando a variável mysql_config_include_files. Ele aceita uma matriz de valores separados por uma vírgula, com um "src" como o prefixo do caminho real no host Ansible.

Primeiro de tudo, temos que preparar os arquivos de configuração personalizados no host Ansible. Crie um diretório e um arquivo de configuração simples do MySQL:

(ansible-host)$ mkdir /root/custom-config/

(ansible-host)$ vim /root/custom-config/my-severalnines.cnf

[mysqld]

max_connections=250

log_bin=binlog

expire_logs_days=7

Digamos que temos outro arquivo de configuração especificamente para configuração do mysqldump:

(ansible-host)$ vim /root/custom-config/mysqldump.cnf

[mysqldump]

max_allowed_packet=128M

Para importar esses arquivos de configuração para nossa implantação, defina-os no array mysql_config_include_files no arquivo vars/main.yml:

mysql_root_password: "theR00tP455w0rd"

mysql_databases:

  - name: example_db

    encoding: latin1

    collation: latin1_general_ci

  - name: sysbench

    encoding: latin1

    collation: latin1_general_ci

mysql_users:

  - name: example_user

    host: "%"

    password: similarly-secure-password

    priv: "example_db.*:ALL"

  - name: sysbench_user

    host: "192.168.0.%"

    password: sysBenchPassw0rd

    priv: "sysbench.*:ALL"

mysql_slow_query_log_enabled: true

mysql_slow_query_log_file: slow_query.log

mysql_slow_query_time: 5

mysql_config_include_files: [

  src: '/root/custom-config/my-severalnines.cnf',

  src: '/root/custom-config/mysqldump.cnf'

]

Observe que /root/custom-config/mysqld-severalnines.cnf e /root/custom-config/mysqldump.cnf existem dentro do host Ansible.

Execute novamente o manual:

(ansible-host)$ ansible-playbook deploy-mysql.yml

O manual irá importar esses arquivos de configuração e colocá-los no diretório de inclusão (dependendo do sistema operacional) que é /etc/my.cnf.d/ para CentOS 7. O manual irá reiniciar automaticamente o servidor MySQL para carregar as novas opções de configuração. Podemos então verificar se as novas opções de configuração estão carregadas corretamente:

(mysql-host)$ mysql -uroot -p -e 'select @@max_connections'

250

(mysql-host)$ mysqldump --help | grep ^max-allowed-packet

max-allowed-packet                134217728

Conclusão