# Amazon RDS para MariaDB
O Amazon RDS é compatível com várias versões do MariaDB para instâncias de banco de dados. Para ter informações completas sobre as versões compatíveis, consulte [MariaDB em versões do Amazon RDS](MariaDB.Concepts.VersionMgmt.md).
Para criar uma instância de banco de dados do MariaDB, use as ferramentas de gerenciamento ou interfaces do Amazon RDS. Depois, você pode usar as ferramentas do Amazon RDS para realizar ações de gerenciamento para a instância de banco de dados. Essas ações incluem o seguinte:
+ Reconfigurar ou redimensionar a instância de banco de dados
+ Autorizar conexões com a instância de banco de dados
+ Criar e restaurar a partir de backups ou snapshots
+ Criar secundários de multi-AZ
+ Criar réplicas de leitura
+ Monitorar a performance de sua instância de banco de dados
Para armazenar e acessar os dados em sua instância de banco de dados, use utilitários e aplicações padrão do MariaDB.
O MariaDB está disponível em todas as Regiões da AWS. Para obter mais informações sobre o Regiões da AWS, consulte [Regiões, zonas de disponibilidade e Local Zones](Concepts.RegionsAndAvailabilityZones.md).
Você pode usar bancos de dados do Amazon RDS para MariaDB para criar aplicativos em conformidade com a norma HIPAA. É possível armazenar informações relacionadas à saúde, inclusive informações de saúde protegidas (PHI), sob um Acordo de associado comercial (BAA) com AWS. Para obter mais informações, consulte [Compatibilidade com a HIPAA](https://aws.amazon.com/compliance/hipaa-compliance/). AWS Os serviços no escopo foram totalmente avaliados por um auditor terceirizado e resultam em uma certificação, declaração de compatibilidade ou Authority to Operate (ATO). Para obter mais informações, consulte [Serviços da AWS no escopo por programa de conformidade](https://aws.amazon.com/compliance/services-in-scope/).
Antes de criar uma instância de banco de dados, conclua as etapas em [Configuração do ambiente do Amazon RDS](CHAP_SettingUp.md). Ao criar uma instância de banco de dados, o usuário principal do RDS obtém privilégios de DBA, com algumas limitações. Use essa conta para tarefas administrativas, como a criação de contas de banco de dados adicionais.
Você pode criar o seguinte:
+ Instâncias de banco de dados
+ DB snapshots
+ Restaurações point-in-time
+ Backups automatizados
+ Backups manuais
Você pode usar instâncias de banco de dados executando o MariaDB em uma nuvem privada virtual (VPC) com base na Amazon VPC. Também é possível adicionar recursos à sua instância de banco de dados do MariaDB ativando várias opções. O Amazon RDS é compatível com implantações multi-AZ para MariaDB como uma solução de failover de alta disponibilidade.
**Importante**
Para oferecer uma experiência de serviço gerenciada, o Amazon RDS não fornece acesso ao shell para as instâncias de banco de dados. Também restringe o acesso a determinados procedimentos e tabelas do sistema que necessitam de privilégios avançados. É possível acessar seu banco de dados usando clientes SQL padrão, como o cliente mysql. No entanto, não é possível acessar o host diretamente usando Telnet ou Secure Shell (SSH).
**Topics**
+ [Suporte ao recurso MariaDB no Amazon RDS](MariaDB.Concepts.FeatureSupport.md)
+ [MariaDB em versões do Amazon RDS](MariaDB.Concepts.VersionMgmt.md)
+ [Conectar-se à instância de banco de dados do MariaDB](USER_ConnectToMariaDBInstance.md)
+ [Proteger as conexões de instância de banco de dados do MariaDB](securing-mariadb-connections.md)
+ [Melhorar a performance das consultas para o RDS para MariaDB com leituras otimizadas do Amazon RDS](rds-optimized-reads-mariadb.md)
+ [Melhorar a performance das gravações com gravações otimizadas pelo Amazon RDS para MariaDB](rds-optimized-writes-mariadb.md)
+ [Atualizações do mecanismo de banco de dados do MariaDB](USER_UpgradeDBInstance.MariaDB.md)
+ [Atualizar uma versão do mecanismo de snapshot de banco de dados do MariaDB](mariadb-upgrade-snapshot.md)
+ [Importar dados para uma instância de banco de dados do Amazon RDS para MariaDB](MariaDB.Procedural.Importing.md)
+ [Como trabalhar com a replicação do MariaDB no Amazon RDS](USER_MariaDB.Replication.md)
+ [Opções para o mecanismo de banco de dados do MariaDB](Appendix.MariaDB.Options.md)
+ [Parâmetros para MariaDB](Appendix.MariaDB.Parameters.md)
+ [Migrar dados de um snapshot de banco de dados do MySQL para uma instância de banco de dados do MariaDB](USER_Migrate_MariaDB.md)
+ [Referência do MariaDB no SQL do Amazon RDS](Appendix.MariaDB.SQLRef.md)
+ [Fuso horário local para as instâncias de banco de dados do MariaDB](MariaDB.Concepts.LocalTimeZone.md)
+ [Limitações e problemas conhecidos do RDS para MariaDB](CHAP_MariaDB.Limitations.md)
# Suporte ao recurso MariaDB no Amazon RDS
O RDS para MariaDB é compatível com os recursos do MariaDB. Alguns recursos podem ter suporte limitado ou privilégios restritos.
Você pode filtrar novos recursos do Amazon RDS na página [What's New with Database? (Novidades sobre bancos de dados)](https://aws.amazon.com/about-aws/whats-new/database/). Em **Products** (Produtos), escolha **Amazon RDS**. Em seguida, pesquise usando palavras-chave como **MariaDB 2023**.
**nota**
As listas a seguir não são completas.
Consulte mais informações sobre o suporte a recursos do MariaDB no Amazon RDS nos tópicos a seguir.
**Tópicos**
+ [Mecanismos de armazenamento compatíveis com MariaDB no Amazon RDS](MariaDB.Concepts.Storage.md)
+ [Aquecimento de cache do MariaDB no Amazon RDS](MariaDB.Concepts.XtraDBCacheWarming.md)
+ [Recursos do MariaDB incompatíveis com o Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md)
## Suporte a recursos do MariaDB nas versões principais do Amazon RDS para MariaDB
Nas seções a seguir, localize informações sobre compatibilidade de recursos do MariaDB nas versões principais do Amazon RDS para MariaDB:
**Topics**
+ [Suporte para MariaDB 11.8 no Amazon RDS](#MariaDB.Concepts.FeatureSupport.11-8)
+ [Suporte para MariaDB 11.4 no Amazon RDS](#MariaDB.Concepts.FeatureSupport.11-4)
+ [Compatibilidade do MariaDB 10.11 com o Amazon RDS](#MariaDB.Concepts.FeatureSupport.10-11)
+ [Compatibilidade do MariaDB 10.6 com o Amazon RDS](#MariaDB.Concepts.FeatureSupport.10-6)
+ [Suporte para MariaDB 10.5 no Amazon RDS](#MariaDB.Concepts.FeatureSupport.10-5)
+ [Suporte para MariaDB 10.4 no Amazon RDS](#MariaDB.Concepts.FeatureSupport.10-4)
Para obter informações sobre versões secundárias compatíveis do Amazon RDS para MariaDB, consulte [MariaDB em versões do Amazon RDS](MariaDB.Concepts.VersionMgmt.md).
### Suporte para MariaDB 11.8 no Amazon RDS
O Amazon RDS oferece suporte aos novos recursos descritos a seguir para instâncias de banco de dados que executam o MariaDB versão 11.8 ou posterior.
**nota**
No MariaDB 11.8, o valor padrão para `require_secure_transport` agora é `1`, exigindo conexões SSL/TLS seguras. Defina como `0` se forem necessárias conexões não seguras.
+ **Novo valor padrão para o parâmetro**: o valor padrão do parâmetro `require_secure_transport` foi alterado de `0` para `1`, impondo conexões de transporte seguras por padrão. Para obter mais informações, consulte [Exigir SSL/TLS para todas as conexões com uma instância de banco de dados do MariaDB no Amazon RDS](mariadb-ssl-connections.require-ssl.md).
+ **Suporte vetorial**: você pode usar o MariaDB Vector para armazenar e pesquisar vetores gerados por IA diretamente no MariaDB. Esse recurso apresenta as seguintes variáveis de sistema:
+ A variável [https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_default_distance](https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_default_distance) especifica a métrica de distância padrão para a indexação vetorial MHNSW.
+ A variável [https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_default_m](https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_default_m) define o valor padrão para o parâmetro `M` na indexação vetorial MHNSW.
+ A variável [https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_ef_search](https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_ef_search) define o número mínimo de candidatos a resultados para pesquisas de índices vetoriais.
+ A variável [https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_max_cache_size](https://mariadb.com/docs/server/reference/sql-structure/vectors/vector-system-variables#mhnsw_max_cache_size) define o limite superior para um cache de índice vetorial MHNSW.
+ **Limites de tamanho de arquivos temporários**: agora você pode limitar o tamanho dos arquivos e tabelas temporários do disco criados usando duas variáveis de sistema disponíveis no grupo de parâmetros do RDS Maria DB 11.8:
+ A variável [https://mariadb.com/docs/server/security/limiting-size-of-created-disk-temporary-files-and-tables/max_tmp_session_space_usage-system-variable](https://mariadb.com/docs/server/security/limiting-size-of-created-disk-temporary-files-and-tables/max_tmp_session_space_usage-system-variable) limita a permissão de espaço temporário por usuário.
+ A variável [https://mariadb.com/docs/server/security/limiting-size-of-created-disk-temporary-files-and-tables/max_tmp_total_space_usage-system-variable](https://mariadb.com/docs/server/security/limiting-size-of-created-disk-temporary-files-and-tables/max_tmp_total_space_usage-system-variable) limita a permissão de espaço temporário para todos os usuários.
+ **Gerenciamento de espaço para tabela temporário**: o espaço para tabela temporário armazena tabelas temporárias e cresce à medida que os dados são adicionados. Quando as tabelas temporárias são eliminadas, o espaço não é recuperado automaticamente. Você pode usar o procedimento [mysql.rds\$1execute\$1operation](mysql_rds_execute_operation.md) para reduzir o espaço para tabela temporário e recuperar o espaço em disco.
Para conferir uma lista de todos os recursos do MariaDB 11.8 com a respectiva documentação, consulte [Changes and improvements in MariaDB 11.8](https://mariadb.com/kb/en/changes-improvements-in-mariadb-11-8/) e [Release notes - MariaDB 11.8 series](https://mariadb.com/kb/en/release-notes-mariadb-11-8-series/) no site do MariaDB.
Para conferir uma lista de recursos não compatíveis, consulte [Recursos do MariaDB incompatíveis com o Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
### Suporte para MariaDB 11.4 no Amazon RDS
O Amazon RDS oferece suporte aos novos recursos descritos a seguir para instâncias de banco de dados que executam o MariaDB versão 11.4 ou posterior.
+ **Biblioteca criptográfica**: o RDS para MariaDB substituiu o OpenSSL pelo AWS Libcrypto (AWS-LC), que tem certificação da norma FIPS 140-3.
+ **Simple Password Check Plugin**: é possível usar o [Simple Password Check Plugin](https://mariadb.com/kb/en/simple-password-check-plugin/) do MariaDB para conferir se uma senha contém pelo menos um número específico de caracteres de determinado tipo. Para obter mais informações, consulte [Usar o plug-in de validação de senhas do RDS para MariaDB](MariaDB.Concepts.PasswordValidationPlugins.md).
+ **Cracklib Password Check Plugin**: é possível usar o [Cracklib Password Check Plugin](https://mariadb.com/kb/en/cracklib-password-check-plugin/) do MariaDB para conferir a força das novas senhas. Para obter mais informações, consulte [Usar o plug-in de validação de senhas do RDS para MariaDB](MariaDB.Concepts.PasswordValidationPlugins.md).
+ **Aprimoramentos do InnoDB**: os aprimoramentos abaixo incluem os seguintes itens:
+ O buffer de alteração foi removido. Para ter mais informações, consulte [InnoDB Change Buffering](https://mariadb.com/kb/en/innodb-change-buffering/).
+ A desfragmentação do InnoDB foi removida. Para ter mais informações, consulte [InnoDB Defragmentation](https://mariadb.com/kb/en/defragmenting-innodb-tablespaces/#innodb-defragmentation).
+ **Novo privilégio**: o usuário administrador agora também tem o privilégio `SHOW CREATE ROUTINE`. Esse privilégio permite que o beneficiário visualize a instrução de definição `SHOW CREATE` de uma rotina pertencente a outro usuário. Para ter mais informações, consulte [Database Privileges](https://mariadb.com/kb/en/grant/#database-privileges).
+ **Melhoria na replicação**: as instâncias de banco de dados do MariaDB versão 11.4 oferecem suporte à indexação de logs binários. É possível criar um índice GTID para cada arquivo de log binário. Esses índices melhoram o desempenho da replicação ao reduzir o tempo necessário para localizar um GTID. Para ter mais informações, consulte [Binlog Indexing](https://mariadb.com/kb/en/gtid/#binlog-indexing).
+ **Parâmetros descontinuados ou removidos**: os seguintes parâmetros foram descontinuados ou removidos para instâncias de banco de dados do MariaDB versão 11.4:
+ `engine_condition_pushdown` foi removido de [optimizer\$1switch](https://mariadb.com/kb/en/optimizer-switch/)
+ [innodb\$1change\$1buffer\$1max\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_change_buffer_max_size)
+ [innodb\$1defragment](https://mariadb.com/kb/en/innodb-system-variables/#innodb_defragment)
+ `TLSv1.0` e `TLSv1.1` foram removidos de [tls\$1version](https://mariadb.com/kb/en/ssltls-system-variables/#tls_version)
+ **Novos valores padrão para um parâmetro**: o valor padrão do parâmetro [innodb\$1undo\$1tablespaces](https://mariadb.com/kb/en/innodb-system-variables/#innodb_undo_tablespaces) foi alterado de `0` para `3`.
+ **Novos valores padrão para parâmetros**: os seguintes parâmetros têm novos valores padrão para instâncias de banco de dados do MariaDB versão 11.4:
+ Os valores válidos para o parâmetro [binlog\$1row\$1image](https://mariadb.com/kb/en/replication-and-binary-log-system-variables/#binlog_row_image) agora incluem `FULL_NODUP`.
+ Os valores válidos para o parâmetro [OLD\$1MODE](https://mariadb.com/kb/en/old-mode/) agora incluem `NO_NULL_COLLATION_IDS`.
+ **Novos parâmetros**: os seguintes parâmetros são novos para instâncias de banco de dados do MariaDB versão 11.4:
+ O parâmetro [transaction\$1isolation](https://mariadb.com/kb/en/server-system-variables/#transaction_isolation) substitui o parâmetro [tx\$1isolation](https://mariadb.com/kb/en/server-system-variables/#tx_isolation).
+ O parâmetro [transaction\$1read\$1only](https://mariadb.com/kb/en/server-system-variables/#transaction_read_only) substitui o parâmetro [tx\$1read\$1only](https://mariadb.com/kb/en/server-system-variables/#tx_read_only).
+ O parâmetro [block\$1encryption\$1mode](https://mariadb.com/kb/en/server-system-variables/#block_encryption_mode) define o modo de criptografia de bloco padrão para as funções [AES\$1ENCRYPT()](https://mariadb.com/kb/en/aes_encrypt/) e [AES\$1DECRYPT()](https://mariadb.com/kb/en/aes_decrypt/).
+ O parâmetro [character\$1set\$1collations](https://mariadb.com/kb/en/server-system-variables/#character_set_collations) define substituições para agrupamentos padrão de conjuntos de caracteres.
+ Os parâmetros [binlog\$1gtid\$1index](https://mariadb.com/kb/en/system-versioned-tables/#binlog_gtid_index), [binlog\$1gtid\$1index\$1page\$1size](https://mariadb.com/kb/en/system-versioned-tables/#binlog_gtid_index_page_size) e [binlog\$1gtid\$1index\$1span\$1min](https://mariadb.com/kb/en/system-versioned-tables/#binlog_gtid_index_span_min) definem as propriedades do índice GTID do log binário. Para ter mais informações, consulte [Binlog Indexing](https://mariadb.com/kb/en/gtid/#binlog-indexing).
Para conferir uma lista de todos os recursos do MariaDB 11.4 com a respectiva documentação, consulte [Changes and improvements in MariaDB 11.4](https://mariadb.com/kb/en/changes-improvements-in-mariadb-11-4/) e [Release notes - MariaDB 11.4 series](https://mariadb.com/kb/en/release-notes-mariadb-11-4-series/) no site do MariaDB.
Para conferir uma lista de recursos não compatíveis, consulte [Recursos do MariaDB incompatíveis com o Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
### Compatibilidade do MariaDB 10.11 com o Amazon RDS
O Amazon RDS é compatível com estes novos recursos nas instâncias de banco de dados que executam o MariaDB versão 10.11 ou posterior.
+ **Plug-in de verificação de reutilização de senha**: você pode usar o plug-in de verificação de reutilização de senha do MariaDB para impedir que os usuários reutilizem senhas e definir o período de retenção das senhas. Para obter mais informações, consulte [Plug-in de verificação de reutilização de senha](https://mariadb.com/kb/en/password-reuse-check-plugin/).
+ **Autorização GRANT TO PUBLIC**: você pode conceder privilégios a todos os usuários que têm acesso ao seu servidor. Para obter mais informações, consulte [GRANT TO PUBLIC](https://mariadb.com/kb/en/grant/#to-public).
+ **Separação dos privilégios SUPER e READ ONLY ADMIN**: você pode remover os privilégios READ ONLY ADMIN de todos os usuários, mesmo aqueles que anteriormente tinham privilégios SUPER.
+ **Segurança**: agora você pode definir a opção `--ssl` como padrão para seu cliente MariaDB. O MariaDB não desabilita mais silenciosamente o SSL se a configuração estiver incorreta.
+ **Comandos e funções SQL**: agora você pode usar o comando `SHOW ANALYZE FORMAT=JSON` e as funções `ROW_NUMBER`, `SFORMAT` e `RANDOM_BYTES`. `SFORMAT` permite a formatação de strings e é habilitado por padrão. Você pode converter partição em tabela e tabela em partição usando um único comando. Há também várias melhorias em torno das funções `JSON_*()`. As funções `DES_ENCRYPT` e `DES_DECRYPT` foram descontinuadas na versão 10.10 e posterior. Para obter mais informações, consulte [SFORMAT](https://mariadb.com/kb/en/sformat/).
+ **Aprimoramentos do InnoDB**: os aprimoramentos abaixo incluem os seguintes itens:
+ Melhorias na performance do redo log para reduzir a amplificação de gravação e melhorar a simultaneidade.
+ A possibilidade de alterar o espaço de tabela undo sem reinicializar o diretório de dados. Esse aprimoramento reduz as despesas operacionais indiretas do ambiente de gerenciamento. É necessário reiniciar, mas não é preciso reinicializar após a alteração do espaço de tabela undo.
+ Suporte para `CHECK TABLE … EXTENDED` e para índices descendentes internamente.
+ Melhorias na inserção em massa.
+ **Alterações no log binário**: essas mudanças incluem os seguintes itens:
+ Registro em log de `ALTER` em duas fases para diminuir a latência da replicação. O parâmetro `binlog_alter_two_phase` é desabilitado por padrão, mas pode ser habilitado por meio de grupos de parâmetros.
+ Registro em log de `explicit_defaults_for_timestamp`.
+ Não há mais registro em log de `INCIDENT_EVENT` quando a transação pode ser revertida com segurança.
+ **Melhorias** **na replicação**: as instâncias de banco de dados do MariaDB versão 10.11 usam a replicação GTID por padrão quando a principal a comporta. Além disso, `Seconds_Behind_Master` é mais preciso.
+ **Clientes**: você pode usar novas opções de linha de comando para `mysqlbinglog` e `mariadb-dump`. Você pode usar `mariadb-dump` para despejar e restaurar dados históricos.
+ **Versionamento do sistema**: você pode modificar o histórico. O MariaDB cria automaticamente novas partições.
+ **DDL atômico**: `CREATE OR REPLACE` agora é atômico. Se a instrução não for bem-sucedida, ela será totalmente revertida.
+ **Gravação de redo log**: o redo log grava de forma assíncrona.
+ **Funções armazenadas**: as funções armazenadas agora comportam os mesmos parâmetros `IN`, `OUT` e `INOUT` dos procedimentos armazenados.
+ **Parâmetros obsoletos ou removidos**: os seguintes parâmetros foram descontinuados ou removidos para instâncias de banco de dados do MariaDB versão 10.11:
+ [innodb\$1change\$1buffering](https://mariadb.com/kb/en/innodb-system-variables/#innodb_change_buffering)
+ [innodb\$1disallow\$1writes](https://mariadb.com/kb/en/innodb-system-variables/#innodb_disallow_writes)
+ [innodb\$1log\$1write\$1ahead\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_log_write_ahead_size)
+ [ innodb\$1prefix\$1index\$1cluster\$1optimization](https://mariadb.com/kb/en/innodb-system-variables/#innodb_prefix_index_cluster_optimization)
+ [ keep\$1files\$1on\$1create](https://mariadb.com/kb/en/server-system-variables/#keep_files_on_create)
+ [old](https://mariadb.com/kb/en/server-system-variables/#old)
+ **Parâmetros dinâmicos**: os seguintes parâmetros agora são dinâmicos para instâncias de banco de dados do MariaDB versão 10.11:
+ [innodb\$1log\$1file\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_log_file_size)
+ [innodb\$1write\$1io\$1threads](https://mariadb.com/kb/en/innodb-system-variables/#innodb_write_io_threads)
+ [innodb\$1read\$1io\$1threads](https://mariadb.com/kb/en/innodb-system-variables/#innodb_read_io_threads)
+ **Novos valores padrão para parâmetros**: os seguintes parâmetros têm novos valores padrão para instâncias de banco de dados MariaDB versão 10.11:
+ O valor padrão do parâmetro [explicit\$1defaults\$1for\$1timestamp](https://mariadb.com/kb/en/server-system-variables/#explicit_defaults_for_timestamp) foi alterado de `OFF` para `ON`.
+ O valor padrão do parâmetro [optimizer\$1prune\$1level](https://mariadb.com/kb/en/server-system-variables/#optimizer_prune_level)foi alterado de `1` para `2`.
+ **Novos valores padrão para parâmetros**: os seguintes parâmetros têm novos valores padrão para instâncias de banco de dados MariaDB versão 10.11:
+ Os valores válidos para o parâmetro [old](https://mariadb.com/kb/en/server-system-variables/#old) foram mesclados com aqueles para o parâmetro [old-mode](https://mariadb.com/kb/en/server-system-variables/#old_mode).
+ Os valores válidos para o parâmetro [histogram\$1type](https://mariadb.com/kb/en/server-system-variables/#histogram_type) agora incluem `JSON_HB`.
+ O intervalo de valores válido para o parâmetro [innodb\$1log\$1buffer\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_log_buffer_size) agora vai de `262144` a `4294967295` (de 256 KB a 4.096 MB).
+ O intervalo de valores válido para o parâmetro [innodb\$1log\$1file\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_log_file_size) agora vai de `4194304` a `512GB` (de 4 MB a 512 GB).
+ Os valores válidos para o parâmetro [optimizer\$1prune\$1level](https://mariadb.com/kb/en/server-system-variables/#optimizer_prune_level) agora incluem `2`.
+ **Novos parâmetros**: os seguintes parâmetros agora são dinâmicos para instâncias de banco de dados do MariaDB versão 10.11:
+ O parâmetro [binlog\$1alter\$1two\$1phase](https://mariadb.com/kb/en/replication-and-binary-log-system-variables//#binlog_alter_two_phase) pode melhorar a performance da replicação.
+ O parâmetro [log\$1slow\$1min\$1examined\$1row\$1limit](https://mariadb.com/kb/en/server-system-variables/#log_slow_min_examined_row_limit) pode melhorar a performance.
+ Os parâmetros [log\$1slow\$1query](https://mariadb.com/kb/en/server-system-variables/#log_slow_query) e [arquivo\$1log\$1slow\$1query](https://mariadb.com/kb/en/server-system-variables/#log_slow_query_file) são aliases de `slow_query_log` e `slow_query_log_file`, respectivamente.
+ [ optimizer\$1extra\$1pruning\$1depth](https://mariadb.com/kb/en/server-system-variables/#optimizer_extra_pruning_depth)
+ [system\$1versioning\$1insert\$1history](https://mariadb.com/kb/en/system-versioned-tables/#system_versioning_insert_history)
Para conferir uma lista de todos os recursos do MariaDB 10.11 com a respectiva documentação, consulte [Changes and improvements in MariaDB 10.11](https://mariadb.com/kb/en/changes-improvements-in-mariadb-1011/) e [Release notes - MariaDB 10.11 series](https://mariadb.com/kb/en/release-notes-mariadb-1011-series/) no site do MariaDB.
Para conferir uma lista de recursos não compatíveis, consulte [Recursos do MariaDB incompatíveis com o Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
### Compatibilidade do MariaDB 10.6 com o Amazon RDS
O Amazon RDS é compatível com estes novos recursos nas instâncias de banco de dados que executam o MariaDB versão 10.6 ou posterior:
+ **Mecanismo de armazenamento do MyRocks**: você pode usar o mecanismo de armazenamento MyRocks com o RDS para MariaDB para otimizar o consumo de armazenamento de suas aplicações Web de alta performance com uso intenso de gravação. Para obter mais informações, consulte [Mecanismos de armazenamento compatíveis com MariaDB no Amazon RDS](MariaDB.Concepts.Storage.md) e [MyRocks](https://mariadb.com/kb/en/myrocks/).
+ **Autenticação de banco de dados AWS Identity and Access Management (IAM)**: você pode usar a autenticação de banco de dados do IAM para melhorar a segurança e o gerenciamento central de conexões com suas instâncias de banco de dados do MariaDB. Para obter mais informações, consulte [Autenticação do banco de dados do IAMpara MariaDB, MySQL e PostgreSQL](UsingWithRDS.IAMDBAuth.md).
+ **Opções de atualização**: agora você pode atualizar para o RDS para MariaDB versão 10.6 de qualquer versão principal anterior (10.3, 10.4, 10.5). Também é possível restaurar um snapshot de uma instância de banco de dados do MySQL 5.6 ou 5.7 existente para uma instância do MariaDB 10.6. Para obter mais informações, consulte [Atualizações do mecanismo de banco de dados do MariaDB](USER_UpgradeDBInstance.MariaDB.md).
+ **Replicação atrasada**: já é possível definir um período configurável pelo qual uma réplica de leitura fica atrasada em relação ao banco de dados de origem. Em uma configuração de replicação padrão do MariaDB, há um atraso mínimo de replicação entre a origem e a réplica. Com a replicação atrasada, é possível definir um atraso intencional como estratégia para a recuperação de desastres. Para obter mais informações, consulte [Configurar a replicação atrasada com o MariaDB](USER_MariaDB.Replication.ReadReplicas.DelayReplication.md).
+ **Compatibilidade com o Oracle PL/SQL**: usando o RDS para MariaDB versão 10.6, você pode migrar mais facilmente suas aplicações Oracle herdadas para o Amazon RDS. Para obter mais informações, consulte [SQL\$1MODE=ORACLE](https://mariadb.com/kb/en/sql_modeoracle/).
+ **DDL atômico**: suas instruções Dynamic Data Language (DDL – Linguagem de dados dinâmica) podem ser relativamente seguras contra falhas com o RDS para MariaDB versão 10.6. As instruções `CREATE TABLE`, `ALTER TABLE`, `RENAME TABLE`, `DROP TABLE`, `DROP DATABASE` e outras instruções DDL relacionadas agora são atômicas. Se a instrução não for bem-sucedida, ela será totalmente revertida. Para obter mais informações, consulte [Atomic DDL](https://mariadb.com/kb/en/atomic-ddl/) (DDL atômica).
+ **Outros aprimoramentos**: esses aprimoramentos incluem uma função `JSON_TABLE` para transformar dados JSON em formato relacional dentro do SQL e carregamento de dados de tabela vazia mais rápido com o InnoDB. Eles também incluem um novo `sys_schema` para análise e solução de problemas, aprimoramento do otimizador para ignorar índices não utilizados e melhorias de performance. Para obter mais informações, consulte [JSON\$1TABLE](https://mariadb.com/kb/en/json_table/).
+ **Novos valores padrão para parâmetros** – os seguintes parâmetros têm novos valores padrão para instâncias de banco de dados MariaDB versão 10.6:
+ O valor padrão dos seguintes parâmetros foi alterado de `utf8` para `utf8mb3`:
+ [character\$1set\$1client](https://mariadb.com/kb/en/server-system-variables/#character_set_client)
+ [character\$1set\$1connection](https://mariadb.com/kb/en/server-system-variables/#character_set_connection)
+ [character\$1set\$1results](https://mariadb.com/kb/en/server-system-variables/#character_set_results)
+ [character\$1set\$1system](https://mariadb.com/kb/en/server-system-variables/#character_set_system)
Embora os valores padrões tenham sido alterados por esses parâmetros, não há alteração funcional. Para obter mais informações, consulte [Supported Character Sets and Collations](https://mariadb.com/kb/en/supported-character-sets-and-collations/) (Conjuntos e agrupamentos de caracteres compatíveis) na documentação do MariaDB.
+ O valor padrão do parâmetro [collation\$1connection](https://mariadb.com/kb/en/server-system-variables/#collation_connection) foi alterado de `utf8_general_ci` para `utf8mb3_general_ci`. Embora o valor padrão tenha sido alterado para esse parâmetro, não há alteração funcional.
+ O valor padrão do parâmetro [old\$1mode](https://mariadb.com/kb/en/server-system-variables/#old_mode) mudou de não definido para `UTF8_IS_UTF8MB3`. Embora o valor padrão tenha sido alterado para esse parâmetro, não há alteração funcional.
Para obter uma lista de todos os recursos do MariaDB 10.6 e sua respectiva documentação, consulte [Changes and improvements in MariaDB 10.6](https://mariadb.com/kb/en/changes-improvements-in-mariadb-106/) (Alterações e melhorias no MariaDB 10.6) e [Release notes - MariaDB 10.6 series](https://mariadb.com/kb/en/release-notes-mariadb-106-series/) (Notas de lançamento - série MariaDB 10.6) no site do MariaDB.
Para conferir uma lista de recursos não compatíveis, consulte [Recursos do MariaDB incompatíveis com o Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
### Suporte para MariaDB 10.5 no Amazon RDS
O Amazon RDS oferece suporte a estes novos recursos nas instâncias de banco de dados que executam o MariaDB versão 10.5 ou posterior:
+ **Melhorias do InnoDB**– o MariaDB versão 10.5 inclui melhorias no InnoDB. Para obter mais informações, consulte [ InnoDB: Performance Improvements etc.](https://mariadb.com/kb/en/changes-improvements-in-mariadb-105/#innodb-performance-improvements-etc) (InnoDB: melhorias na performance, etc.) na documentação do MariaDB.
+ **Atualizações do esquema de performance** – o MariaDB versão 10.5 inclui atualizações do esquema de performance. Para obter mais informações, consulte [ Performance Schema Updates to Match MySQL 5.7 Instrumentation and Tables](https://mariadb.com/kb/en/changes-improvements-in-mariadb-105/#performance-schema-updates-to-match-mysql-57-instrumentation-and-tables) (Atualizações do esquema de performance correspondentes a instrumentação e tabelas do MariaDB).
+ **Um arquivo no redo log do InnoDB** – nas versões do MariaDB anteriores à versão 10.5, o valor do parâmetro `innodb_log_files_in_group` foi definido como `2`. No MariaDB versão 10.5, o valor desse parâmetro é definido como `1`.
Se você estiver atualizando de uma versão anterior para o MariaDB versão 10.5 e não modificar os parâmetros, o valor do parâmetro `innodb_log_file_size` será inalterado. No entanto, ele se aplica a um arquivo de log em vez de dois. O resultado é que a instância de banco de dados MariaDB versão 10.5 atualizada usa metade do tamanho do redo log que estava usando antes da atualização. Essa mudança pode ter um impacto notável na performance. Para resolver esse problema, você pode dobrar o valor do parâmetro `innodb_log_file_size`. Para obter informações sobre como modificar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
+ **Comando SHOW SLAVE STATUS sem suporte** – em versões do MariaDB anteriores à versão 10.5, o comando `SHOW SLAVE STATUS` exigia o privilégio `REPLICATION SLAVE`. Na versão 10.5 do MariaDB, o comando `SHOW REPLICA STATUS` equivalente requer o privilégio `REPLICATION REPLICA ADMIN`. Esse novo privilégio não é concedido ao usuário mestre do RDS.
Em vez de usar o comando `SHOW REPLICA STATUS`, execute o novo procedimento `mysql.rds_replica_status` armazenado para retornar informações semelhantes. Para obter mais informações, consulte [mysql.rds\$1replica\$1status](mysql_rds_replica_status.md).
+ **Comando SHOW RELAYLOG EVENTS sem suporte** – em versões do MariaDB anteriores à versão 10.5, o comando `SHOW RELAYLOG EVENTS` exigiu o privilégio `REPLICATION SLAVE`. Na versão 10.5 do MariaDB, esse comando requer o privilégio `REPLICATION REPLICA ADMIN`. Esse novo privilégio não é concedido ao usuário mestre do RDS.
+ **Novos valores padrão para parâmetros** – os seguintes parâmetros têm novos valores padrão para instâncias de banco de dados MariaDB versão 10.5:
+ O valor padrão do parâmetro [max\$1connections](https://mariadb.com/kb/en/server-system-variables/#max_connections) foi alterado para `LEAST({DBInstanceClassMemory/25165760},12000)`. Para obter informações sobre a função do parâmetro `LEAST`, consulte [Funções de parâmetros de banco de dados](USER_ParamValuesRef.md#USER_ParamFunctions).
+ O valor padrão do parâmetro [ innodb\$1adaptive\$1hash\$1index](https://mariadb.com/kb/en/innodb-system-variables/#innodb_adaptive_hash_index) foi alterado para `OFF` (`0`).
+ O valor padrão do parâmetro [ innodb\$1checksum\$1algorithm](https://mariadb.com/kb/en/innodb-system-variables/#innodb_checksum_algorithm) foi alterado para `full_crc32`.
+ O valor padrão do parâmetro [innodb\$1log\$1file\$1size](https://mariadb.com/kb/en/innodb-system-variables/#innodb_log_file_size) foi alterado para 2 GB.
Para obter uma lista de todos os recursos do MariaDB 10.5 e suas respectivas documentações, consulte [Changes and improvements in MariaDB 10.5](https://mariadb.com/kb/en/changes-improvements-in-mariadb-105/) e [Release notes - MariaDB 10.5 series](https://mariadb.com/kb/en/release-notes-mariadb-105-series/) no site do MariaDB.
Para ver uma lista de recursos não compatíveis, consulte [Recursos do MariaDB incompatíveis com o Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
### Suporte para MariaDB 10.4 no Amazon RDS
O Amazon RDS oferece suporte a estes novos recursos nas instâncias de banco de dados executando o MariaDB versão 10.4 ou posterior:
+ **Melhorias de segurança da conta do usuário** – [Expiração da senha](https://mariadb.com/kb/en/user-password-expiry/) e melhorias no [bloqueio de conta](https://mariadb.com/kb/en/account-locking/)
+ **Melhorias do otimizador** – [recurso Optimizer Trace](https://mariadb.com/kb/en/optimizer-trace-overview/)
+ **Melhorias do InnoDB ** – [Suporte instantâneo a DROP COLUMN](https://mariadb.com/kb/en/alter-table/#drop-column) e extensão `VARCHAR` instantânea para `ROW_FORMAT=DYNAMIC` e `ROW_FORMAT=COMPACT`
+ **Novos parâmetros** – Incluindo [tcp\$1nodedelay](https://mariadb.com/kb/en/server-system-variables/#tcp_nodelay), [tls\$1version](https://mariadb.com/kb/en/ssltls-system-variables/#tls_version) e [gtid\$1cleanup\$1batch\$1size](https://mariadb.com/kb/en/gtid/#gtid_cleanup_batch_size)
Para obter uma lista de todos os recursos do MariaDB 10.4 e suas respectivas documentações, consulte [Changes and improvements in MariaDB 10.4](https://mariadb.com/kb/en/library/changes-improvements-in-mariadb-104/) e [Release notes - MariaDB 10.4 series](https://mariadb.com/kb/en/library/release-notes-mariadb-104-series/) no site do MariaDB.
Para ver uma lista de recursos não compatíveis, consulte [Recursos do MariaDB incompatíveis com o Amazon RDS](MariaDB.Concepts.FeatureNonSupport.md).
# Mecanismos de armazenamento compatíveis com MariaDB no Amazon RDS
O RDS para MariaDB é compatível com os seguintes mecanismos de armazenamento.
**Topics**
+ [O mecanismo de armazenamento InnoDB](#MariaDB.Concepts.Storage.InnoDB)
+ [O mecanismo de armazenamento MyRocks](#MariaDB.Concepts.Storage.MyRocks)
Atualmente, não há suporte a outros mecanismos de armazenamento para o RDS para MariaDB.
## O mecanismo de armazenamento InnoDB
Embora o MariaDB suporte vários mecanismos de armazenamento com recursos variados, nem todos eles são otimizados para durabilidade de dados e recuperação. O InnoDB é o mecanismo de armazenamento recomendado para instâncias de banco de dados MariaDB no Amazon RDS. Os recursos de restauração point-in-time e de snapshot do Amazon RDS exigem um mecanismo de armazenamento de recuperação de falha e são compatíveis somente com o mecanismo de armazenamento para a versão MariaDB.
Para obter mais informações, consulte [InnoDB](https://mariadb.com/kb/en/innodb/).
## O mecanismo de armazenamento MyRocks
O mecanismo de armazenamento MyRocks está disponível no RDS para MariaDB versão 10.6 e posteriores. Antes de usar o mecanismo de armazenamento MyRocks em um banco de dados de produção, recomendamos que você execute testes e benchmarking completos para verificar quaisquer benefícios potenciais em relação ao InnoDB para seu caso de uso.
O grupo de parâmetros padrão para o MariaDB versão 10.6 inclui parâmetros do MyRocks. Para obter mais informações, consulte [Parâmetros para MariaDB](Appendix.MariaDB.Parameters.md) e [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
Para criar uma tabela que usa o mecanismo de armazenamento MyRocks, especifique `ENGINE=RocksDB` na instrução `CREATE TABLE`. O exemplo a seguir cria uma tabela que usa o mecanismo de armazenamento MyRocks.
```
CREATE TABLE test (a INT NOT NULL, b CHAR(10)) ENGINE=RocksDB;
```
É altamente recomendável não executar transações que envolvam as tabelas do InnoDB e do MyRocks. O MariaDB não garante ACID (atomicidade, consistência, isolamento, durabilidade) para transações em todos os mecanismos de armazenamento. Embora seja possível ter tabelas InnoDB e MyRocks em uma instância de banco de dados, não recomendamos essa abordagem, exceto durante uma migração de um mecanismo de armazenamento para o outro. Quando há tabelas InnoDB e MyRocks em uma instância de banco de dados, cada mecanismo de armazenamento tem seu próprio grupo de buffers, o que pode causar degradação da performance.
O MyRocks não é compatível com o isolamento de `SERIALIZABLE` ou bloqueios de lacunas. Portanto, geralmente você não pode usar o MyRocks com replicação baseada em instruções. Para obter mais informações, consulte [MyRocks and Replication](https://mariadb.com/kb/en/myrocks-and-replication/) (MyRocks e replicação).
Atualmente, você só pode modificar os seguintes parâmetros do MyRocks:
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_block_cache_size](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_block_cache_size)
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_bulk_load](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_bulk_load)
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_bulk_load_size](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_bulk_load_size)
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_deadlock_detect](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_deadlock_detect)
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_deadlock_detect_depth](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_deadlock_detect_depth)
+ [https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_max_latest_deadlocks](https://mariadb.com/kb/en/myrocks-system-variables/#rocksdb_max_latest_deadlocks)
O mecanismo de armazenamento MyRocks e o mecanismo de armazenamento InnoDB podem competir pela memória com base nas configurações dos parâmetros `rocksdb_block_cache_size` e `innodb_buffer_pool_size`. Em alguns casos, você pode ter a intenção de usar apenas o mecanismo de armazenamento MyRocks em uma instância de banco de dados específica. Se for o caso, recomendamos definir o parâmetro `innodb_buffer_pool_size minimal` para um valor mínimo e o `rocksdb_block_cache_size` para o valor mais alto possível.
Você pode acessar os arquivos de log do MyRocks usando as operações [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBLogFiles.html) e [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DownloadDBLogFilePortion.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DownloadDBLogFilePortion.html).
Para obter mais informações sobre o MyRocks, consulte [MyRocks](https://mariadb.com/kb/en/myrocks/) no site do MariaDB.
# Aquecimento de cache do MariaDB no Amazon RDS
O aquecimento de cache do InnoDB pode fornecer ganhos de performance para sua instância de banco de dados do MariaDB salvando o estado atual do grupo de buffer quando a instância de banco de dados é desativada e, em seguida, recarregando o grupo de buffer a partir das informações salvas quando a instância do banco de dados for iniciada. Essa abordagem ignora a necessidade de o grupo de buffer "aquecer" do uso normal de banco de dados e, em vez disso, pré-carrega o grupo de buffer com as páginas para consultas comuns conhecidas. Para obter mais informações sobre o aquecimento de cache, consulte [Despejo e restauração do grupo de buffers](http://mariadb.com/kb/en/mariadb/xtradbinnodb-buffer-pool/#dumping-and-restoring-the-buffer-pool) na documentação do MariaDB.
O aquecimento de cache está habilitado por padrão para instâncias de banco de dados do MariaDB 10.3 e posteriores. Para habilitá-lo, defina os parâmetros `innodb_buffer_pool_dump_at_shutdown` e `innodb_buffer_pool_load_at_startup` para 1 no grupo de parâmetros da sua instância de banco de dados. Mudar esses valores de parâmetro em um grupo de parâmetros afeta todas as instâncias de banco de dados do MariaDB que usam esse grupo de parâmetros. Para habilitar o aquecimento de cache para instâncias específicas de banco de dados do MariaDB, talvez seja necessário criar um grupo de parâmetros nessas instâncias de banco de dados. Para obter informações sobre grupos de parâmetros, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
O aquecimento de cache fornece principalmente um benefício de performance para instâncias de banco de dados que usam armazenamento padrão. Se você usar o armazenamento de PIOPS, não perceberá um benefício significativo de performance normalmente.
**Importante**
Se sua instância de banco de dados do MariaDB não fechar normalmente, por exemplo durante um failover, o estado do grupo de buffer não é salvo no disco. Nesse caso, o MariaDB carrega qualquer arquivo de grupo de buffer disponível quando a instância de banco de dados for reiniciada. Não há problema, mas o grupo de buffer restaurado pode não refletir o estado mais recente do grupo de buffer antes do reinício. Para garantir que você tenha um estado recente do grupo de buffer disponível para aquecer o cache do na inicialização, recomendamos que você descarte periodicamente o grupo de buffer "sob demanda". Você pode descartar ou carregar o grupo de buffer sob demanda.
Você pode criar um evento para descartar o grupo de buffer automaticamente e em um intervalo regular. Por exemplo, a seguinte declaração cria um evento chamado `periodic_buffer_pool_dump` que descarta o grupo de buffer de hora em hora.
```
1. CREATE EVENT periodic_buffer_pool_dump
2. ON SCHEDULE EVERY 1 HOUR
3. DO CALL mysql.rds_innodb_buffer_pool_dump_now();
```
Para obter mais informações, consulte [Eventos](http://mariadb.com/kb/en/mariadb/stored-programs-and-views-events/) na documentação do MariaDB.
## Como descartar e carregar o grupo de buffer sob demanda
Você pode salvar e carregar o cache do sob demanda usando os seguintes procedimentos armazenados:
+ Para descartar o estado atual do grupo de buffer para o disco, chame o procedimento armazenado [mysql.rds\$1innodb\$1buffer\$1pool\$1dump\$1now](mysql-stored-proc-warming.md#mysql_rds_innodb_buffer_pool_dump_now).
+ Para carregar o estado salvo do grupo de buffer a partir do disco, chame o procedimento armazenado [mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1now](mysql-stored-proc-warming.md#mysql_rds_innodb_buffer_pool_load_now).
+ Para cancelar uma operação de carregamento em andamento, chame o procedimento armazenado [mysql.rds\$1innodb\$1buffer\$1pool\$1load\$1abort](mysql-stored-proc-warming.md#mysql_rds_innodb_buffer_pool_load_abort).
# Recursos do MariaDB incompatíveis com o Amazon RDS
Os seguintes recursos do MariaDB não têm suporte no Amazon RDS:
+ Mecanismo de armazenamento do S3
+ Plug-in de autenticação – GSSAPI
+ Plug-in de autenticação – soquete Unix
+ AWSPlugin de criptografia do Key Management
+ Replicação atrasada para versões do MariaDB anteriores à 10.6
+ Criptografia nativa do MariaDB em repouso para InnoDB e Aria
Você pode habilitar a criptografia em repouso para uma instância de banco de dados do MariaDB seguindo as instruções em [Criptografar recursos do Amazon RDS](Overview.Encryption.md).
+ HandlerSocket
+ Tipo de tabela JSON para versões do MariaDB anteriores à 10.6
+ MariaDB ColumnStore
+ Cluster Galera do MariaDB
+ Replicação em várias origens
+ Mecanismo de armazenamento MyRocks para versões do MariaDB anteriores à 10.6
+ Plug-in de validação de senha, `simple_password_check` e `cracklib_password_check` para versões do MariaDB inferiores a 11.4
+ Mecanismo de armazenamento do Spider
+ Mecanismo de armazenamento do Sphinx
+ Mecanismo de armazenamento do TokuDB
+ Atributos de objeto específicos do mecanismo de armazenamento, conforme descrito em [Atributos de nova tabela/campo/índice definidos pelo mecanismo](http://mariadb.com/kb/en/mariadb/engine-defined-new-tablefieldindex-attributes/) na documentação do MariaDB
+ Criptografia de tabela e do espaço de tabela
+ Plug-in de gerenciamento de chaves Hashicorp
+ Executar duas atualizações em paralelo
Para oferecer uma experiência de serviço gerenciado, o Amazon RDS não fornece acesso ao shell para instâncias de bancos de dados e restringe o acesso a determinados procedimentos e tabelas do sistema que exigem privilégios avançados. O Amazon RDS oferece suporte a acesso a bancos de dados em uma instância de banco de dados que usa qualquer aplicação de cliente SQL padrão. O Amazon RDS não permite o acesso direto do host a uma instância de banco de dados usando Telnet, Secure Shell (SSH) ou Windows Remote Desktop Connection.
# MariaDB em versões do Amazon RDS
No MariaDB, os números de versão são organizados como versão X.Y.Z. Na terminologia do Amazon RDS, X.Y representa a versão principal, e Z é o número da versão secundária. Para implementações do Amazon RDS, uma alteração da versão é considerada primária se o número da versão primária for alterado, por exemplo, da versão 10.5 para a 10.6. Uma alteração da versão será considerada secundária se apenas o número da versão secundária for alterado; por exemplo, da versão 10.6.14 para a 10.6.16.
**Topics**
+ [Versões secundárias do MariaDB compatíveis com o Amazon RDS](#MariaDB.Concepts.VersionMgmt.Supported)
+ [Versões principais do MariaDB compatíveis com o Amazon RDS](#MariaDB.Concepts.VersionMgmt.ReleaseCalendar)
+ [Trabalhar com o ambiente de visualização de banco de dados](#mariadb-working-with-the-database-preview-environment)
+ [MariaDB versão 11.7 no Ambiente de Pré-visualização do Banco de Dados](#mariadb-preview-environment-version-11-7)
+ [Versões obsoletas do Amazon RDS para MariaDB](#MariaDB.Concepts.DeprecatedVersions)
## Versões secundárias do MariaDB compatíveis com o Amazon RDS
Atualmente, o Amazon RDS é compatível com as versões secundárias do MariaDB a seguir.
**nota**
As datas com apenas mês e ano são aproximadas e são atualizadas com uma data exata quando ela é conhecida.
A tabela a seguir mostra as versões secundárias do MariaDB 11.8 atualmente compatíveis com o Amazon RDS.
| Versão do mecanismo do MariaDB | Data de lançamento para a comunidade | Data de lançamento do RDS | Data do fim do suporte padrão para o RDS |
| --- | --- | --- | --- |
| 11.8.6 | 04 de fevereiro de 2026 | 10 de fevereiro de 2026 | Fevereiro de 2027 |
| 11.8.5 | 14 de novembro de 2025 | 20 de novembro de 2025 | Novembro de 2026 |
| 11.8.3 | 6 de agosto de 2025 | 25 de agosto de 2025 | Setembro de 2026 |
A tabela a seguir mostra as versões secundárias do MariaDB 11.4 atualmente compatíveis com o Amazon RDS.
| Versão do mecanismo do MariaDB | Data de lançamento para a comunidade | Data de lançamento do RDS | Data do fim do suporte padrão para o RDS |
| --- | --- | --- | --- |
| 11.4.10 | 04 de fevereiro de 2026 | 10 de fevereiro de 2026 | Fevereiro de 2027 |
| 11.4.9 | 6 de novembro de 2025 | 18 de novembro de 2025 | Novembro de 2026 |
| 11.4.8 | 6 de agosto de 2025 | 13 de agosto de 2025 | Setembro de 2026 |
| 11.4.7 | 22 de maio de 2025 | 4 de junho de 2025 | Setembro de 2026 |
| 11.4.5 | 4 de fevereiro de 2025 | 24 de fevereiro de 2025 | Maio de 2026 |
| 11.4.4 | 1.º de novembro de 2024 | 20 de dezembro de 2024 | Maio de 2026 |
| 11.4.3 | 8 de agosto de 2024 | 15 de outubro de 2024 | Maio de 2026 |
No momento, a tabela a seguir mostra as versões secundárias do MariaDB 10.11 compatíveis com o Amazon RDS.
| Versão do mecanismo do MariaDB | Data de lançamento para a comunidade | Data de lançamento do RDS | Data do fim do suporte padrão para o RDS |
| --- | --- | --- | --- |
| 10.11.16 | 04 de fevereiro de 2026 | 10 de fevereiro de 2026 | Fevereiro de 2027 |
| 10.11.15 | 6 de novembro de 2025 | 18 de novembro de 2025 | Novembro de 2026 |
| 10.11.14 | 6 de agosto de 2025 | 13 de agosto de 2025 | Setembro de 2026 |
| 10.11.13 | 22 de maio de 2025 | 4 de junho de 2025 | Setembro de 2026 |
| 10.11.11 | 4 de fevereiro de 2025 | 24 de fevereiro de 2025 | Maio de 2026 |
| 10.11.10 | 1.º de novembro de 2024 | 20 de dezembro de 2024 | Maio de 2026 |
| 10.11.9 | 8 de agosto de 2024 | 4 de setembro de 2024 | Maio de 2026 |
No momento, a tabela a seguir mostra as versões secundárias do MariaDB 10.6 compatíveis com o Amazon RDS.
| Versão do mecanismo do MariaDB | Data de lançamento para a comunidade | Data de lançamento do RDS | Data do fim do suporte padrão para o RDS |
| --- | --- | --- | --- |
| 10.6.25 | 04 de fevereiro de 2026 | 10 de fevereiro de 2026 | Julho de 2026 |
| 10.6.24 | 6 de novembro de 2025 | 18 de novembro de 2025 | Julho de 2026 |
| 10.6.23 | 6 de agosto de 2025 | 13 de agosto de 2025 | Julho de 2026 |
| 10.6.22 | 6 de maio de 2025 | 20 de maio de 2025 | Julho de 2026 |
| 10.6.21 | 4 de fevereiro de 2025 | 24 de fevereiro de 2025 | Maio de 2026 |
| 10.6.20 | 1.º de novembro de 2024 | 20 de dezembro de 2024 | Maio de 2026 |
| 10.6.19 | 8 de agosto de 2024 | 4 de setembro de 2024 | Maio de 2026 |
No momento, a tabela a seguir mostra as versões secundárias do MariaDB 10.5 compatíveis com o Amazon RDS.
| Versão do mecanismo do MariaDB | Data de lançamento para a comunidade | Data de lançamento do RDS | Data do fim do suporte padrão para o RDS |
| --- | --- | --- | --- |
| 10.5.29 | 6 de maio de 2025 | 20 de maio de 2025 | Junho de 2026 |
| 10.5.28 | 4 de fevereiro de 2025 | 24 de fevereiro de 2025 | Junho de 2026 |
| 10.5.27 | 1.º de novembro de 2024 | 20 de dezembro de 2024 | Maio de 2026 |
Você pode especificar qualquer versão compatível atualmente do MariaDB ao criar uma nova instância de banco de dados. Você pode especificar a versão principal (como o MariaDB 10.5) e qualquer versão secundária com suporte para a versão principal especificada. Se nenhuma versão for especificada, o Amazon RDS usará uma versão compatível por padrão, geralmente a versão mais recente. Se uma versão principal for especificada, mas uma versão secundária não, o Amazon RDS usará por padrão um lançamento recente da versão principal que você especificou. Para ver uma lista de versões com suporte, bem como os padrões para instâncias de banco de dados recém-criadas, use o comando da `describe-db-engine-versions` [AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-engine-versions.html).
Por exemplo, para listar as versões de mecanismo compatíveis com o RDS para MariaDB, execute o comando da CLI a seguir:
```
aws rds describe-db-engine-versions --engine mariadb --query "*[].{Engine:Engine,EngineVersion:EngineVersion}" --output text
```
A versão padrão do MariaDB pode variar de acordo com a Região da AWS. Para criar uma instância de banco de dados com uma versão secundária específica, especifique a versão secundária durante a criação da instância de banco de dados. É possível determinar a versão secundária padrão para uma Região da AWS executando o seguinte comando da AWS CLI:
```
aws rds describe-db-engine-versions --default-only --engine mariadb --engine-version major_engine_version --region region --query "*[].{Engine:Engine,EngineVersion:EngineVersion}" --output text
```
Substitua *major-engine-version* pela versão principal do mecanismo e substitua *region* pela Região da AWS. Por exemplo, o comando da AWS CLI a seguir retorna a versão secundária padrão do mecanismo do MariaDB para a versão principal 10.5 e a Região da AWS Oeste dos EUA (Oregon) (us-west-2):
```
aws rds describe-db-engine-versions --default-only --engine mariadb --engine-version 10.5 --region us-west-2 --query "*[].{Engine:Engine,EngineVersion:EngineVersion}" --output text
```
### Versões secundárias do MariaDB no Amazon RDS
**Topics**
+ [MariaDB versão 11.8.6](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.8.6)
+ [MariaDB versão 11.8.5](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.8.5)
+ [MariaDB versão 11.8.3](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.8.3)
+ [MariaDB versão 11.4.10](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.10)
+ [MariaDB versão 11.4.9](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.9)
+ [MariaDB versão 11.4.8](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.8)
+ [MariaDB versão 11.4.7](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.7)
+ [MariaDB versão 11.4.5](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.5)
+ [MariaDB versão 11.4.4](#MariaDB.Concepts.VersionMgmt.Supported.Minor.11.4.4)
+ [MariaDB versão 10.11.16](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.16)
+ [MariaDB versão 10.11.15](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.15)
+ [MariaDB versão 10.11.14](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.14)
+ [MariaDB versão 10.11.13](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.13)
+ [MariaDB versão 10.11.11](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.11)
+ [MariaDB versão 10.11.10](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.11.10)
+ [MariaDB versão 10.6.25](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.25)
+ [MariaDB versão 10.6.24](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.24)
+ [MariaDB versão 10.6.23](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.23)
+ [MariaDB versão 10.6.22](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.22)
+ [MariaDB versão 10.6.21](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.21)
+ [MariaDB versão 10.6.20](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.6.20)
+ [MariaDB versão 10.5.29](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.5.29)
+ [MariaDB versão 10.5.28](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.5.28)
+ [MariaDB versão 10.5.27](#MariaDB.Concepts.VersionMgmt.Supported.Minor.10.5.27)
#### MariaDB versão 11.8.6
O MariaDB versão 11.8.6 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar como base `tzdata2025c`.
+ Corrigido um problema que pode fazer com que algumas instruções SQL não sejam registradas no log de auditoria.
#### MariaDB versão 11.8.5
O MariaDB versão 11.8.5 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
#### MariaDB versão 11.8.3
O MariaDB versão 11.8.3 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ **Novo valor padrão para o parâmetro**: o valor padrão do parâmetro `require_secure_transport` foi alterado de `0` para `1`, impondo conexões de transporte seguras por padrão. Para obter mais informações, consulte [Exigir SSL/TLS para todas as conexões com uma instância de banco de dados do MariaDB no Amazon RDS](mariadb-ssl-connections.require-ssl.md).
#### MariaDB versão 11.4.10
O MariaDB versão 11.4.10 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar como base `tzdata2025c`.
+ Corrigido um problema que pode fazer com que algumas instruções SQL não sejam registradas no log de auditoria.
#### MariaDB versão 11.4.9
O MariaDB versão 11.4.9 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
#### MariaDB versão 11.4.8
O MariaDB versão 11.4.8 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
#### MariaDB versão 11.4.7
O MariaDB versão 11.4.7 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar como base `tzdata2025b`.
#### MariaDB versão 11.4.5
O MariaDB versão 11.4.5 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar `tzdata2025a` como base.
#### MariaDB versão 11.4.4
O MariaDB versão 11.4.4 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Revertidas duas alterações da comunidade MariaDB que causam falha na recuperação para um ponto no tempo (PITR). Para obter mais informações, consulte o [problema MDEV-35528 do MariaDB Server Jira](https://jira.mariadb.org/browse/MDEV-35528).
#### MariaDB versão 10.11.16
O MariaDB versão 10.11.16 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar como base `tzdata2025c`.
+ Corrigido um problema que pode fazer com que algumas instruções SQL não sejam registradas no log de auditoria.
#### MariaDB versão 10.11.15
O MariaDB versão 10.11.15 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
#### MariaDB versão 10.11.14
O MariaDB versão 10.11.14 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
#### MariaDB versão 10.11.13
O MariaDB versão 10.11.13 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar como base `tzdata2025b`.
#### MariaDB versão 10.11.11
O MariaDB versão 10.11.11 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar `tzdata2025a` como base.
#### MariaDB versão 10.11.10
O MariaDB versão 10.11.10 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Revertidas duas alterações da comunidade MariaDB que causam falha na recuperação para um ponto no tempo (PITR). Para obter mais informações, consulte o [problema MDEV-35528 do MariaDB Server Jira](https://jira.mariadb.org/browse/MDEV-35528).
#### MariaDB versão 10.6.25
O MariaDB versão 10.6.25 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar como base `tzdata2025c`.
+ Corrigido um problema que pode fazer com que algumas instruções SQL não sejam registradas no log de auditoria.
#### MariaDB versão 10.6.24
O MariaDB versão 10.6.24 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
#### MariaDB versão 10.6.23
O MariaDB versão 10.6.23 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
#### MariaDB versão 10.6.22
O MariaDB versão 10.6.22 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar como base `tzdata2025b`.
#### MariaDB versão 10.6.21
O MariaDB versão 10.6.21 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar `tzdata2025a` como base.
#### MariaDB versão 10.6.20
O MariaDB versão 10.6.20 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Revertidas duas alterações da comunidade MariaDB que causam falha na recuperação para um ponto no tempo (PITR). Para obter mais informações, consulte o [problema MDEV-35528 do MariaDB Server Jira](https://jira.mariadb.org/browse/MDEV-35528).
#### MariaDB versão 10.5.29
O MariaDB versão 10.5.29 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar como base `tzdata2025b`.
#### MariaDB versão 10.5.28
O MariaDB versão 10.5.28 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Atualização das informações de fuso horário para usar `tzdata2025a` como base.
#### MariaDB versão 10.5.27
O MariaDB versão 10.5.27 já está disponível no Amazon RDS. Essa versão contém correções e melhorias adicionadas pela comunidade do MariaDB e pelo Amazon RDS.
**Novos recursos e aprimoramentos**
+ Revertidas duas alterações da comunidade MariaDB que causam falha na recuperação para um ponto no tempo (PITR). Para obter mais informações, consulte o [problema MDEV-35528 do MariaDB Server Jira](https://jira.mariadb.org/browse/MDEV-35528).
## Versões principais do MariaDB compatíveis com o Amazon RDS
As principais versões do RDS para MariaDB continuam disponíveis pelo menos até o fim da vida útil da comunidade para a versão da comunidade correspondente. É possível usar as seguintes datas para planejar seus ciclos de teste e atualização. Se a Amazon estender o suporte para uma versão do RDS para MariaDB por mais tempo do que o planejado originalmente, planejamos atualizar essa tabela para refletir a data posterior.
**nota**
As datas com apenas mês e ano são aproximadas e são atualizadas com uma data exata quando ela é conhecida.
Você também pode visualizar informações sobre datas de suporte para as versões principais do mecanismo executando o comando [describe-db-major-engine-versions](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-major-engine-versions.html)AWS CLI ou usando a operação de API [DescribeDBMajorEngineVersions](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBMajorEngineVersions.html) do RDS.
| Versão principal do MariaDB | Data de lançamento para a comunidade | Data de lançamento do RDS | Data do fim da vida útil para a comunidade | Data do fim do suporte padrão para o RDS |
| --- | --- | --- | --- | --- |
| MariaDB 11.8 | 6 de agosto de 2025 | 25 de agosto de 2025 | Junho de 2030 | Junho de 2030 |
| MariaDB 11.4 | 8 de agosto de 2024 | 15 de outubro de 2024 | Maio de 2029 | Maio de 2029 |
| MariaDB 10.11 | 16 de fevereiro de 2023 | 21 de agosto de 2023 | 16 de fevereiro de 2028 | Fevereiro de 2028 |
| MariaDB 10.6 | 6 de julho de 2021 | 3 de fevereiro de 2022 | 6 de julho de 2026 | Agosto de 2026 |
| MariaDB 10.5 | 24 de junho de 2020 | 21 de janeiro de 2021 | 24 de junho de 2025 | Agosto de 2026 |
## Trabalhar com o ambiente de visualização de banco de dados
As instâncias de banco de dados do RDS para MariaDB no ambiente de versão prévia do banco de dados são semelhantes às outras instâncias do RDS para MariaDB em termos de funcionalidade. No entanto, você não pode usar o ambiente Database Preview para cargas de trabalho de produção.
Os ambientes prévios têm as seguintes limitações:
+ Todas as instâncias de banco de dados são excluídas 60 dias após serem criadas, juntamente com backups e snapshots.
+ Você só pode usar o SSD de uso geral e o armazenamento em SSD IOPS provisionadas.
+ Você não pode obter ajuda do Suporte para instâncias de banco de dados. Em vez disso, você pode postar suas perguntas na comunidade de perguntas e respostas gerenciadas pela AWS, o [AWS re:Post](https://repost.aws/tags/TAsibBK6ZeQYihN9as4S_psg/amazon-relational-database-service).
+ Não é possível copiar um snapshot de uma instância de banco de dados para um ambiente de produção.
As opções a seguir são compatíveis com a visualização.
+ Você pode criar instâncias de banco de dados usando as classes de instância de banco de dados db.m6i, db.r6i, db.m6g, db.m5, db.t3, db.r6g e db.r5. Para obter mais informações sobre as classes de instância do RDS, consulte [Classes de instâncias de banco de dados do ](Concepts.DBInstanceClass.md).
+ É possível usar implantações single-AZ e multi-AZ.
+ É possível usar funções padrão de despejo e de carregamento do MariaDB para exportar ou importar bancos de dados para o ambiente de versão prévia do banco de dados.
### Atributos não compatíveis com o ambiente de visualização de banco de dados
Os atributos a seguir não estão disponíveis no ambiente de visualização de banco de dados:
+ Cópia de snapshots entre regiões
+ Réplicas de leitura entre regiões
+ RDS Proxy
### Criar uma nova instância de banco de dados no ambiente de visualização de banco de dados
Você pode criar uma instância de banco de dados no ambiente Database Preview usando o Console de gerenciamento da AWSAWS CLI, a ou a API do RDS.
#### Console
**Para criar uma instância de banco de dados no ambiente de visualização de banco de dados**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Escolha **Dashboard** (Painel) no painel de navegação.
1. Na página **Painel**, localize a seção **Ambiente de versão prévia do banco de dados**, conforme mostrado na imagem a seguir.
![\[A seção Ambiente de versão prévia do banco de dados com link no console do Amazon RDS.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/preview-environment-dashboard.png)
Você também pode navegar diretamente para o [Ambiente de visualização do banco de dados](https://us-east-2.console.aws.amazon.com/rds-preview/home?region=us-east-2#). Antes de continuar, você deve reconhecer e aceitar as limitações.
![\[A caixa de diálogo Acordo de Serviço do Ambiente de Versão Prévia do Banco de Dados para reconhecer as limitações.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/preview-environment-console.png)
1. Para criar a instância de banco de dados do RDS para MariaDB, siga o mesmo processo de criação de qualquer instância de banco de dados do Amazon RDS. Para obter mais informações, consulte o procedimento [Console](USER_CreateDBInstance.md#USER_CreateDBInstance.CON) em [Criar uma instância de banco de dados](USER_CreateDBInstance.md#USER_CreateDBInstance.Creating).
#### AWS CLI
Para criar uma instância no ambiente de visualização do banco de dados usando a API do RDS ou a AWS CLI, use o endpoint a seguir.
```
rds-preview.us-east-2.amazonaws.com
```
Para criar a instância de banco de dados do RDS para MariaDB, siga o mesmo processo de criação de qualquer instância de banco de dados do Amazon RDS. Para obter mais informações, consulte o procedimento [AWS CLI](USER_CreateDBInstance.md#USER_CreateDBInstance.CLI) em [Criar uma instância de banco de dados](USER_CreateDBInstance.md#USER_CreateDBInstance.Creating).
#### API do RDS
Para criar uma instância no ambiente de visualização do banco de dados usando a API do RDS ou a , use o endpoint a seguir.
```
rds-preview.us-east-2.amazonaws.com
```
Para criar a instância de banco de dados do RDS para MariaDB, siga o mesmo processo de criação de qualquer instância de banco de dados do Amazon RDS. Para obter mais informações, consulte o procedimento [API do RDS](USER_CreateDBInstance.md#USER_CreateDBInstance.API) em [Criar uma instância de banco de dados](USER_CreateDBInstance.md#USER_CreateDBInstance.Creating).
## MariaDB versão 11.7 no Ambiente de Pré-visualização do Banco de Dados
O MariaDB versão 11.7 já está disponível no Ambiente de Pré-visualização do Banco de Dados do Amazon RDS. O MariaDB versão 11.7 contém várias melhorias descritas em [Changes and improvements in MariaDB 11.7](https://mariadb.com/kb/en/changes-improvements-in-mariadb-11-7/). Esta versão também inclui suporte para o tipo de dados de vetores, indexação e pesquisa. Consulte mais informações em [Vector Overview](https://mariadb.com/kb/en/vector-overview/) na documentação do MariaDB.
É possível usar o ambiente de versão prévia do banco de dados para testar as workloads em relação a essa versão antes que ela esteja disponível em todas as Regiões da AWS para workloads de produção. Para obter informações sobre o ambiente de visualização de banco de dados, consulte [Trabalhar com o ambiente de visualização de banco de dados](#mariadb-working-with-the-database-preview-environment). Para acessar o ambiente de versão prévia do console, selecione [rds-preview/](https://console.aws.amazon.com/rds-preview/).
## Versões obsoletas do Amazon RDS para MariaDB
As versões 10.0, 10.1, 10.2 e 10.3 do Amazon RDS para MariaDB estão obsoletas.
Para obter informações sobre a política de defasagem do Amazon RDS para o MariaDB, consulte [Perguntas frequentes sobre o Amazon RDS](https://aws.amazon.com/rds/faqs/).
# Conectar-se à instância de banco de dados do MariaDB
Depois que o Amazon RDS provisionar a sua instância de banco de dados, será possível usar qualquer utilitário ou aplicativo cliente MariaDB padrão para se conectar à instância. Na string de conexão, especifique o endereço DNS (Domain Name System) do endpoint da instância de banco de dados como o parâmetro de host. Especifique também o número da porta do endpoint da instância de banco de dados como o parâmetro da porta.
É possível se conectar a uma instância de banco de dados do Amazon RDS para MariaDB usando ferramentas como o cliente MySQL de linha de comando. Para ter mais informações sobre como usar o cliente MySQL de linha de comando, consulte [mysql command-line client](http://mariadb.com/kb/en/mariadb/mysql-command-line-client/), na documentação do MariaDB. O Heidi é uma aplicação baseada em GUI que você pode usar para se conectar. Para ter mais informações, consulte a página [Download HeidiSQL](http://www.heidisql.com/download.php). Para obter informações sobre como instalar o MySQL (incluindo o cliente MySQL de linha de comando), consulte [Installing and upgrading MySQL](https://dev.mysql.com/doc/refman/8.0/en/installing.html) (Instalar e atualizar o MySQL).
A maioria das distribuições do Linux inclui o cliente MariaDB em vez do cliente Oracle MySQL. Para instalar o cliente da linha de comando do MySQL no Amazon Linux 2023, execute o seguinte comando:
```
sudo dnf install mariadb105
```
Para instalar o cliente da linha de comando do MySQL no Amazon Linux 2, execute o seguinte comando:
```
sudo yum install mariadb
```
Para instalar o cliente de linha de comando do MySQL na maioria das distribuições do Linux baseadas em DEB, execute o comando a seguir.
```
apt-get install mariadb-client
```
Para conferir a versão do cliente de linha de comando do MySQL, execute o comando a seguir:
```
mysql --version
```
Para ler a documentação da versão atual do cliente do MySQL, execute o comando a seguir.
```
man mysql
```
Para se conectar a uma instância de banco de dados de fora de uma nuvem privada virtual (VPC) baseada em Amazon VPC, a instância de banco de dados deve estar acessível publicamente. Além disso, o acesso deve ser concedido usando as regras de entrada do grupo de segurança da instância de banco de dados, e os outros requisitos devem ser atendidos. Para ter mais informações, consulte [Não é possível conectar-se à instância de banco de dados do Amazon RDS](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting).
Você pode usar a criptografia SSL em conexões com uma instância de banco de dados MariaDB. Para ter mais informações, consulte [Suporte de SSL/TLS para instâncias de banco de dados do MariaDB no Amazon RDS](MariaDB.Concepts.SSLSupport.md).
Para encontrar uma instância de banco de dados do RDS para MariaDB e conectar-se a ela, consulte os tópicos a seguir.
**Topics**
+ [Localizar as informações de conexão para uma instância de banco de dados MariaDB](USER_ConnectToMariaDBInstance.EndpointAndPort.md)
+ [Conectar-se pelo cliente de linha de comandos do MySQL (descriptografado) para o RDS para MariaDB](USER_ConnectToMariaDBInstance.CLI.md)
+ [Conectar-se ao RDS para MariaDB com o driver JDBC da AWS e o driver Python da AWS](MariaDB.Connecting.Drivers.md)
+ [Solução de problemas de conexões da instância de banco de dados MariaDB](USER_ConnectToMariaDBInstance.Troubleshooting.md)
# Localizar as informações de conexão para uma instância de banco de dados MariaDB
As informações de conexão de uma instância de banco de dados incluem seu endpoint, porta e um usuário de banco de dados válido, como o usuário mestre. Por exemplo, suponha que um valor de endpoint seja `mydb.123456789012.us-east-1.rds.amazonaws.com`. Nesse caso, o valor da porta é `3306`, e o usuário do banco de dados é `admin`. Com essas informações, você especifica os seguintes valores em uma string de conexão:
+ Para o host, nome de host ou nome DNS, especifique `mydb.123456789012.us-east-1.rds.amazonaws.com`.
+ Para a porta, especifique `3306`.
+ Para usuário, especifique `admin`.
Para se conectar a uma instância de banco de dados, use qualquer cliente para o mecanismo de banco de dados do MariaDB. Por exemplo, você pode usar o cliente MySQL de linha de comando ou o MySQL Workbench.
Para localizar as informações de conexão de uma instância de banco de dados, você pode usar o Console de gerenciamento da AWS, comando da AWS Command Line Interface (AWS CLI) [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html) ou a operação da API do Amazon RDS [DescribeDBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html) para listar seus detalhes.
## Console
**Para encontrar as informações de conexão de uma instância de banco de dados no Console de gerenciamento da AWS**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação, escolha **Bancos de dados** para exibir uma lista de suas instâncias de banco de dados.
1. Escolha o nome da instância de banco de dados MariaDB para exibir os detalhes.
1. Na guia **Connectivity & security (Conectividade e segurança)**, copie o endpoint. Além disso, anote o número da porta. Você precisará do endpoint e do número da porta para conectar-se à instância de banco de dados.
![\[O endpoint e a porta de uma instância de banco de dados no console do Amazon RDS.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/endpoint-port.png)
1. Se você precisar encontrar o nome de usuário mestre, escolha a guia **Configuração** e visualize o valor do nome de **usuário mestre** .
## AWS CLI
Para localizar as informações de conexão de uma instância de banco de dados MariaDB usando o AWS CLI, execute o comando [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html). Na chamada, consulte o ID da instância de banco de dados, o endpoint, a porta e o nome de usuário mestre.
Para Linux, macOS ou Unix:
```
aws rds describe-db-instances \
--filters "Name=engine,Values=mariadb" \
--query "*[].[DBInstanceIdentifier,Endpoint.Address,Endpoint.Port,MasterUsername]"
```
Para Windows:
```
aws rds describe-db-instances ^
--filters "Name=engine,Values=mariadb" ^
--query "*[].[DBInstanceIdentifier,Endpoint.Address,Endpoint.Port,MasterUsername]"
```
Sua saída deve ser similar à seguinte.
```
[
[
"mydb1",
"mydb1.123456789012.us-east-1.rds.amazonaws.com",
3306,
"admin"
],
[
"mydb2",
"mydb2.123456789012.us-east-1.rds.amazonaws.com",
3306,
"admin"
]
]
```
## API do RDS
Para localizar as informações de conexão de uma instância de banco de dados usando a Amazon RDS API, chame a operação [DescribeDBInstances](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBInstances.html) . Na saída, encontre os valores para o endereço do endpoint, a porta do endpoint e o nome do usuário mestre.
# Conectar-se pelo cliente de linha de comandos do MySQL (descriptografado) para o RDS para MariaDB
**Importante**
Use uma conexão MySQL não criptografada apenas quando o cliente e o servidor estiverem na mesma VPC e a rede for confiável. Para obter informações sobre como usar conexões criptografadas, consulte [Conectar-se à instância de banco de dados do MariaDB no Amazon RDS com SSL/TLS por meio do cliente de linha de comandos do MySQL (criptografado)](USER_ConnectToMariaDBInstanceSSL.CLI.md).
Para se conectar a uma instância de banco de dados usando o cliente MySQL de linha de comando, insira o comando a seguir em um prompt de comando em um computador cliente. Isso conecta você a um banco de dados em uma instância de banco de dados MariaDB. Substitua o nome DNS (endpoint) da instância de banco de dados *``* e o nome de usuário mestre usado por *``*. Forneça a senha mestra usada quando for solicitada uma senha.
```
mysql -h -P 3306 -u -p
```
Depois de digitar a senha do usuário, você verá uma saída semelhante à seguinte.
```
Welcome to the MariaDB monitor. Commands end with ; or \g.
Your MariaDB connection id is 31
Server version: 10.6.10-MariaDB-log Source distribution
Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
MariaDB [(none)]>
```
# Conectar-se ao RDS para MariaDB com o driver JDBC da AWS e o driver Python da AWS
Conecte-se a instâncias de banco de dados do RDS para MariaDB com o driver JDBC da AWS e o driver Python da AWS. Para obter mais informações, consulte os tópicos a seguir.
**Topics**
+ [Conectar-se ao RDS para MariaDB com o driver JDBC da Amazon Web Services (AWS)](#MariaDB.Connecting.JDBCDriver)
+ [Conectar-se ao RDS para MariaDB com o driver Python da Amazon Web Services (AWS)](#MariaDB.Connecting.PythonDriver)
## Conectar-se ao RDS para MariaDB com o driver JDBC da Amazon Web Services (AWS)
O driver JDBC da Amazon Web Services (AWS) foi projetado como um wrapper JDBC avançado. Esse wrapper é complementar e amplia a funcionalidade do driver JDBC existente. O driver é compatível de forma intercambiável com os drivers MySQL Connector/J e MariaDB Connector/J da comunidade.
Para instalar o driver JDBC da AWS, anexe o arquivo .jar do driver JDBC da AWS (localizado na aplicação `CLASSPATH`) e mantenha referências ao respectivo driver da comunidade. Atualize o respectivo prefixo do URL de conexão da seguinte forma:
+ `jdbc:mysql://` para `jdbc:aws-wrapper:mysql://`
+ `jdbc:mariadb://` para `jdbc:aws-wrapper:mariadb://`
Consulte mais informações sobre o driver JDBC da AWS e siga as instruções para usá-lo em [Amazon Web Services (AWS) JDBC Driver GitHub repository](https://github.com/awslabs/aws-advanced-jdbc-wrapper).
## Conectar-se ao RDS para MariaDB com o driver Python da Amazon Web Services (AWS)
O driver Python da Amazon Web Services (AWS) foi projetado como um wrapper Python avançado. Esse wrapper é complementar e amplia a funcionalidade do driver Psycopg de código aberto. O driver Python da AWS é compatível com as versões 3.8 e posterior do Python. É possível instalar o pacote `aws-advanced-python-wrapper` usando o comando `pip`, bem como os pacotes de código aberto `psycopg`.
Para ter mais informações sobre o driver Python da AWS e instruções completas para usá-lo, consulte [Amazon Web Services (AWS) Python Driver GitHub repository](https://github.com/awslabs/aws-advanced-python-wrapper).
# Solução de problemas de conexões da instância de banco de dados MariaDB
Duas causas comuns de falhas de conexão para uma nova instância de banco de dados são as seguintes:
+ A instância de banco de dados foi criada usando um grupo de segurança que não autoriza conexões do dispositivo ou da instância do Amazon EC2 em que o aplicativo ou utilitário do MariaDB está sendo executado. A instância de banco de dados deve ter um grupo de segurança de VPC que autorize as conexões. Para ter mais informações, consulte [Amazon VPC e Amazon RDS](USER_VPC.md).
É possível adicionar ou editar uma regra de entrada no grupo de segurança. Em **Source (Origem)**, selecione **My IP (Meu IP)**. Isso concede acesso à instância de banco de dados do endereço IP detectado no navegador.
+ A instância de banco de dados foi criada usando a porta padrão 3306 e sua empresa emprega regras de firewall bloqueando conexões a essa porta a partir de dispositivos na rede de sua empresa. Para corrigir essa falha, recrie a instância com uma porta diferente.
Para ter mais informações sobre problemas de conexão, consulte [Não é possível conectar-se à instância de banco de dados do Amazon RDS](CHAP_Troubleshooting.md#CHAP_Troubleshooting.Connecting).
# Proteger as conexões de instância de banco de dados do MariaDB
É possível gerenciar a segurança de suas instâncias de banco de dados do MariaDB.
**Topics**
+ [Segurança do MariaDB no Amazon RDS](MariaDB.Concepts.UsersAndPrivileges.md)
+ [Usar o plug-in de validação de senhas do RDS para MariaDB](MariaDB.Concepts.PasswordValidationPlugins.md)
+ [Criptografar conexões de clientes com SSL/TLS para instâncias de banco de dados do MariaDB no Amazon RDS](mariadb-ssl-connections.md)
+ [Atualizar aplicações para conexão com instâncias do MariaDB usando novos certificados SSL/TLS](ssl-certificate-rotation-mariadb.md)
# Segurança do MariaDB no Amazon RDS
A segurança de instâncias de banco de dados do MariaDB é gerenciada em três níveis:
+ O AWS Identity and Access Management controla quem pode executar ações de gerenciamento do Amazon RDS em instâncias de banco de dados. Ao se conectar à AWS usando credenciais do IAM, sua conta do IAM deve ter políticas do IAM que concedam as permissões necessárias para executar operações de gerenciamento do Amazon RDS. Para ter mais informações, consulte [Gerenciamento de identidade e acesso no Amazon RDS](UsingWithRDS.IAM.md).
+ Quando você cria uma instância de banco de dados, é necessário usar um grupo de segurança da VPC para controlar quais dispositivos e instâncias do Amazon EC2 podem abrir conexões com o endpoint e a porta da instância de banco de dados. É possível estabelecer essas conexões usando o Transport Layer Security (TLS) e o Secure Sockets Layer (SSL). Além disso, as regras de firewall em sua empresa podem controlar se dispositivos sendo executados nela podem abrir conexões na instância de banco de dados.
+ Uma vez que uma conexão foi aberta em uma instância de banco de dados do MariaDB, a autenticação do login e as permissões são aplicadas da mesma forma que em uma instância autônoma do MariaDB. Comandos, como `CREATE USER`, `RENAME USER`, `GRANT`, `REVOKE` e `SET PASSWORD` funcionam exatamente como em bancos de dados autônomos, assim como modificando diretamente tabelas de esquema de banco de dados.
Quando você cria uma instância de banco de dados do Amazon RDS, o usuário mestre apresenta os seguintes privilégios padrão:
+ `alter`
+ `alter routine`
+ `create`
+ `create routine`
+ `create temporary tables`
+ `create user`
+ `create view`
+ `delete`
+ `drop`
+ `event`
+ `execute`
+ `grant option`
+ `index`
+ `insert`
+ `lock tables`
+ `process`
+ `references`
+ `reload`
Esse privilégio é limitado em instâncias de banco de dados MariaDB. Ele não concede acesso às operações `FLUSH LOGS` e `FLUSH TABLES WITH READ LOCK`.
+ `replication client`
+ `replication slave`
+ `select`
+ `show create routine`
Esse privilégio é válido somente em instâncias de banco de dados do MariaDB que executam a versão 11.4 e posterior.
+ `show databases`
+ `show view`
+ `trigger`
+ `update`
Para obter mais informações sobre esses privilégios, consulte [Gerenciamento da conta de usuário](http://mariadb.com/kb/en/mariadb/grant/) na documentação do MariaDB.
**nota**
Embora você possa excluir o usuário mestre em uma instância de banco de dados, não recomendamos fazer isso. Para recriar o usuário mestre, use a API `ModifyDBInstance` ou o `modify-db-instance` AWS CLI e especifique uma nova senha de usuário mestre com o parâmetro apropriado. Se o usuário mestre não existir na instância, ele será criado com a senha especificada.
Para fornecer serviços de gerenciamento para cada instância de banco de dados, o usuário `rdsadmin` é criado quando a instância de banco de dados é criada. Tentar descartar, renomear ou alterar a senha, ou alterar os privilégios, para a conta `rdsadmin` resulta em um erro.
Para permitir o gerenciamento da instância de banco de dados, os comandos `kill` e `kill_query` padrão foram restritos. Os comandos do Amazon RDS `mysql.rds_kill`, `mysql.rds_kill_query` e `mysql.rds_kill_query_id` são fornecidos para uso no MariaDB e também no MySQL para seja possível encerrar sessões ou consultas de usuários em instâncias de banco de dados.
# Usar o plug-in de validação de senhas do RDS para MariaDB
A partir do RDS para MariaDB versão 11.4, é possível usar os seguintes plug-ins de validação de senhas para aprimorar a segurança das conexões a bancos de dados:
+ [simple\$1password\$1check](https://mariadb.com/kb/en/simple-password-check-plugin/): confere se uma senha contém pelo menos um número específico de caracteres de determinado tipo.
+ [cracklib\$1password\$1check](https://mariadb.com/kb/en/cracklib_password_check/): confere se uma senha aparece em um arquivo de dicionário da biblioteca [CrackLib](https://github.com/cracklib/cracklib).
Para habilitar esses plug-ins, defina o valor do parâmetro `simple_password_check` ou `cracklib_password_check` como `FORCE_PLUS_PERMANENT` no grupo de parâmetros de banco de dados associado à instância de banco de dados. Quando esse valor é definido, o plug-in não pode ser desinstalado usando a instrução `UNINSTALL PLUGIN` em tempo de execução.
Para desabilitar esses plug-ins, defina o valor do parâmetro `simple_password_check` ou `cracklib_password_check` como `OFF` no grupo de parâmetros de banco de dados associado à instância de banco de dados. Quando esse valor é definido, as regras de validação do plug-in não se aplicam mais às novas senhas.
Para ter informações sobre como definir os valores dos parâmetros nos respectivos grupos, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
# Criptografar conexões de clientes com SSL/TLS para instâncias de banco de dados do MariaDB no Amazon RDS
O Secure Sockets Layer (SSL) é um protocolo padrão do setor para proteger as conexões de rede entre o cliente e o servidor. Após o SSL versão 3.0, o nome mudou para Transport Layer Security (TLS). O Amazon RDS é compatível com criptografia SSL/TLS para instâncias de banco de dados do MariaDB. Usando o SSL/TLS, você pode criptografar uma conexão entre seu cliente de aplicação e sua instância de banco de dados do MariaDB. A compatibilidade com SSL/TLS está disponível em todas as Regiões da AWS.
Com o Amazon RDS, é possível proteger dados em trânsito criptografando conexões de clientes com instâncias de banco de dados do MariaDB por meio de SSL/TLS, exigindo SSL/TLS para todas as conexões com uma instância de banco de dados do MariaDB e conectando-se pelo cliente da linha de comando do MySQL com SSL/TLS (criptografado). As seções a seguir apresentam orientações sobre como configurar e utilizar a criptografia SSL/TLS para instâncias de banco de dados do MariaDB no Amazon RDS.
**Topics**
+ [Suporte de SSL/TLS para instâncias de banco de dados do MariaDB no Amazon RDS](MariaDB.Concepts.SSLSupport.md)
+ [Exigir SSL/TLS para contas de usuário específicas em uma instância de banco de dados do MariaDB](MariaDB-ssl-connections.require-ssl-users.md)
+ [Exigir SSL/TLS para todas as conexões com uma instância de banco de dados do MariaDB no Amazon RDS](mariadb-ssl-connections.require-ssl.md)
+ [Conectar-se à instância de banco de dados do MariaDB no Amazon RDS com SSL/TLS por meio do cliente de linha de comandos do MySQL (criptografado)](USER_ConnectToMariaDBInstanceSSL.CLI.md)
# Suporte de SSL/TLS para instâncias de banco de dados do MariaDB no Amazon RDS
O Amazon RDS cria um certificado SSL/TLS e instala o certificado na instância de banco de dados quando o Amazon RDS provisionar a instância. Esses certificados são assinados por uma autoridade de certificado. O certificado SSL/TLS inclui o endpoint da instância de banco de dados como o nome comum (CN) do certificado SSL/TLS para se proteger contra ataques de falsificação.
Um certificado SSL/TLS criado pelo Amazon RDS é a entidade raiz confiável e deve funcionar na maioria dos casos, mas poderá falhar se a aplicação não aceitar cadeias de certificados. Se a aplicação não aceitar cadeias de certificados, tente usar um certificado intermediário para se conectar à Região da AWS. Por exemplo, é necessário usar um certificado intermediário para se conectar às regiões AWS GovCloud (US) com SSL/TLS.
Para obter informações sobre como baixar certificados, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md). Para obter mais informações sobre como usar o SSL/TLS com o MySQL, consulte [Atualizar aplicações para conexão com instâncias do MariaDB usando novos certificados SSL/TLS](ssl-certificate-rotation-mariadb.md).
O Amazon RDS para MariaDB é compatível com o Transport Layer Security (TLS) versões 1.3, 1.2, 1.1 e 1.0. A compatibilidade com o TLS depende da versão secundária do MariaDB. A tabela a seguir mostra a compatibilidade das versões secundárias do MariaDB com o TLS.
| Versão do TLS | MariaDB 11.8 | MariaDB 11.4 | MariaDB 10.11 | MariaDB 10.6 | MariaDB 10.5 | MariaDB 10.4 |
| --- | --- | --- | --- | --- | --- | --- |
| TLS 1.3 | Todas as versões secundárias | Todas as versões secundárias | Todas as versões secundárias | Todas as versões secundárias | Todas as versões secundárias | Todas as versões secundárias |
| TLS 1.2 | Todas as versões secundárias | Todas as versões secundárias | Todas as versões secundárias | Todas as versões secundárias | Todas as versões secundárias | Todas as versões secundárias |
| TLS 1.1 | Não suportado | Não suportado | Sem compatibilidade | 10.6.16 e anterior | 10.5.23 e anterior | 10.4.32 e anterior |
| TLS 1.0 | Não suportado | Não suportado | Sem compatibilidade | 10.6.16 e anterior | 10.5.23 e anterior | 10.4.32 e anterior |
# Exigir SSL/TLS para contas de usuário específicas em uma instância de banco de dados do MariaDB
É possível exigir criptografia SSL/TLS para conexões de contas de usuário especificadas com as instâncias de banco de dados do MariaDB no Amazon RDS. Proteger informações confidenciais contra acesso não autorizado ou interceptação é crucial para aplicar políticas de segurança nas quais a confidencialidade dos dados é uma questão importante.
Se deseja exigir conexões SSL/TLS para contas de usuários específicos, siga uma das instruções abaixo (dependendo da versão do MySQL) para exigir conexões SSL/TLS na conta de usuário `encrypted_user`.
Para fazer isso, use a instrução a seguir.
```
ALTER USER 'encrypted_user'@'%' REQUIRE SSL;
```
Para obter mais informações sobre as conexões SSL/TLS com o MariaDB, consulte [Securing Connections for Client and Server](https://mariadb.com/kb/en/securing-connections-for-client-and-server/) (Como proteger conexões para cliente e servidor) na documentação do MariaDB.
# Exigir SSL/TLS para todas as conexões com uma instância de banco de dados do MariaDB no Amazon RDS
Use o parâmetro `require_secure_transport` para exigir que todas as conexões de usuários à sua instância de banco de dados do MariaDB usem SSL/TLS. Para as versões 11.4 e anteriores, o parâmetro `require_secure_transport` é definido como `OFF` por padrão. Para a versão 11.8 e versões posteriores, o valor padrão é definido como `ON`, aplicando SSL/TLS para conexões com a sua instância de banco de dados. Você poderá alterar o parâmetro `require_secure_transport` para `OFF` se forem necessárias conexões não seguras.
**nota**
O parâmetro `require_secure_transport` só é compatível com o MariaDB versão 10.5 e posterior.
Você pode definir o valor de parâmetro `require_secure_transport` atualizando o grupo de parâmetros do banco de dados de sua instância de banco de dados. Você não precisa reinicializar sua instância de banco de dados para que a alteração entre em vigor.
Quando o parâmetro `require_secure_transport` é definido como `ON` para uma instância de banco de dados, um cliente de banco de dados poderá se conectar a ela se puder estabelecer uma conexão criptografada. Caso contrário, uma mensagem de erro semelhante à seguinte é retornada para o cliente:
```
ERROR 1045 (28000): Access denied for user 'USER'@'localhost' (using password: YES | NO)
```
Para obter informações sobre como configurar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
Para obter mais informações sobre o parâmetro `require_secure_transport`, consulte a [documentação do MariaDB](https://mariadb.com/docs/ent/ref/mdb/system-variables/require_secure_transport/).
# Conectar-se à instância de banco de dados do MariaDB no Amazon RDS com SSL/TLS por meio do cliente de linha de comandos do MySQL (criptografado)
Os parâmetros `mysql` do programa cliente serão ligeiramente diferentes, se você estiver usando a versão do MySQL 5.7, a versão do MySQL 8.0 ou a versão do MariaDB.
Para descobrir qual versão você tem, execute o comando `mysql` com a opção `--version`. No exemplo a seguir, a saída mostra que o programa cliente é do MariaDB.
```
$ mysql --version
mysql Ver 15.1 Distrib 10.5.15-MariaDB, for osx10.15 (x86_64) using readline 5.1
```
A maioria das distribuições Linux, como o Amazon Linux, CentOS, SUSE e Debian, substituiu o MySQL pelo MariaDB, e a versão do `mysql` neles é de MariaDB.
Para conectar-se à sua instância de banco de dados usando o SSL/TLS, siga estas etapas:
**Como conectar-se a uma instância de banco de dados com o SSL/TLS usando o cliente de linha de comando do MySQL**
1. Você pode baixar um certificado raiz que funciona para todas as Regiões da AWS.
Para obter informações sobre como baixar certificados, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md).
1. Use um cliente da linha de comando do MySQL para conectar-se a uma instância de banco de dados com criptografia SSL/TLS. Para o parâmetro `-h`, substitua o nome de DNS (endpoint) da instância de banco de dados. Para o parâmetro `--ssl-ca`, substitua o nome do arquivo de certificado SSL/TLS. Para o parâmetro `-P`, substitua a porta da sua instância de banco de dados. Para o parâmetro `-u`, substitua o nome de usuário de um usuário de banco de dados válido, como o usuário principal. Digite a senha do usuário mestre quando lhe for solicitado.
O exemplo a seguir mostra como iniciar o cliente usando o parâmetro `--ssl-ca` usando o cliente MariaDB:
```
mysql -h mysql–instance1.123456789012.us-east-1.rds.amazonaws.com --ssl-ca=global-bundle.pem --ssl -P 3306 -u myadmin -p
```
Para exigir que a conexão SSL/TLS verifique o endpoint da instância de banco de dados em relação ao endpoint no certificado SSL/TLS, insira o seguinte comando:
```
mysql -h mysql–instance1.123456789012.us-east-1.rds.amazonaws.com --ssl-ca=global-bundle.pem --ssl-verify-server-cert -P 3306 -u myadmin -p
```
O exemplo a seguir mostra como iniciar o cliente usando o parâmetro `--ssl-ca` com o MySQL 5.7 e versões posteriores.
```
mysql -h mysql–instance1.123456789012.us-east-1.rds.amazonaws.com --ssl-ca=global-bundle.pem --ssl-mode=REQUIRED -P 3306 -u myadmin -p
```
1. Digite a senha do usuário mestre quando lhe for solicitado.
Você deve ver saída semelhante ao seguinte:
```
Welcome to the MariaDB monitor. Commands end with ; or \g.
Your MariaDB connection id is 31
Server version: 10.6.10-MariaDB-log Source distribution
Copyright (c) 2000, 2018, Oracle, MariaDB Corporation Ab and others.
Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
MariaDB [(none)]>
```
# Atualizar aplicações para conexão com instâncias do MariaDB usando novos certificados SSL/TLS
Em 13 de janeiro de 2023, o Amazon RDS publicou novos certificados de autoridade de certificação (CA) para se conectar às suas instâncias de banco de dados do RDS via Secure Socket Layer ou Transport Layer Security (SSL/TLS). A seguir, você pode encontrar informações sobre como atualizar seus aplicativos para usar os novos certificados.
Este tópico pode ajudá-lo a determinar se seus aplicativos exigem verificação do certificado para se conectar às suas instâncias de bancos de dados.
**nota**
Alguns aplicativos são configurados para se conectar ao MariaDB apenas quando podem verificar com sucesso o certificado no servidor. Para esses aplicativos, você deve atualizar os repositórios confiáveis de aplicativos cliente para incluir os novos certificados de CA.
É possível especificar os seguintes modos SSL: `disabled`, `preferred` e `required`. Quando você usa o modo `preferred` do SSL e o certificado de CA não existe ou não está atualizado, a conexão volta a não usar SSL e ainda se conecta com êxito.
Recomendamos evitar o modo `preferred` No modo `preferred`, se a conexão encontrar um certificado inválido, ele para de usar criptografia e continua sem criptografia.
Depois de atualizar seus certificados de CA nos armazenamentos confiáveis do aplicativo cliente, você pode fazer o rodízio dos certificados nas suas instâncias de banco de dados. É altamente recomendável testar esses procedimentos em um ambiente de desenvolvimento ou teste antes de implementá-los em seus ambientes de produção.
Para obter mais informações sobre a mudança de certificados, consulte [Alternar o certificado SSL/TLS](UsingWithRDS.SSL-certificate-rotation.md). Para obter mais informações sobre como fazer download de certificados, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md). Para obter informações sobre o uso de SSL/TLS com instâncias de bancos de dados MariaDB, consulte [Suporte de SSL/TLS para instâncias de banco de dados do MariaDB no Amazon RDS](MariaDB.Concepts.SSLSupport.md).
**Topics**
+ [Determinar se um cliente requer verificação de certificado para se conectar](#ssl-certificate-rotation-mariadb.determining)
+ [Atualizar o armazenamento confiável de aplicações](#ssl-certificate-rotation-mariadb.updating-trust-store)
+ [Exemplo de código Java para estabelecer conexões SSL](#ssl-certificate-rotation-mariadb.java-example)
## Determinar se um cliente requer verificação de certificado para se conectar
É possível verificar se os clientes JDBC e MySQL exigem verificação de certificado para se conectarem.
### JDBC
O exemplo a seguir com o MySQL Connector/J 8.0 mostra uma maneira de verificar as propriedades da conexão JDBC de um aplicativo para determinar se conexões bem-sucedidas exigem um certificado válido. Para obter mais informações sobre todas as opções de conexão JDBC para MySQL, consulte [Propriedades da configuração](https://dev.mysql.com/doc/connector-j/en/connector-j-reference-configuration-properties.html) na documentação do MySQL.
Ao usar o MySQL Connector/J 8.0, uma conexão SSL exigirá verificação com base no certificado de CA de servidor se as propriedades da sua conexão tiverem `sslMode` definido como `VERIFY_CA` ou `VERIFY_IDENTITY`, como no exemplo a seguir.
```
Properties properties = new Properties();
properties.setProperty("sslMode", "VERIFY_IDENTITY");
properties.put("user", DB_USER);
properties.put("password", DB_PASSWORD);
```
**nota**
Se você usar o MySQL Java Connector v5.1.38 ou posterior, ou o MySQL Java Connector v8.0.9 ou posterior para se conectar a seus bancos de dados, mesmo que você não tenha configurado explicitamente seus aplicativos para usar SSL/TLS ao se conectar a seus bancos de dados, esses drivers cliente usam SSL/TLS como padrão. Além disso, ao usar SSL/TLS, eles executam a verificação parcial do certificado e haverá falha na conexão se o certificado do servidor de banco de dados tiver expirado.
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
### MySQL
Os exemplos a seguir com o cliente MySQL mostram duas maneiras de verificar a conexão MySQL de um script para determinar se conexões bem-sucedidas exigem um certificado válido. Para obter mais informações sobre todas as opções de conexão com o cliente MySQL, consulte [Configuração no lado do cliente para conexões criptografadas](https://dev.mysql.com/doc/refman/en/using-encrypted-connections.html#using-encrypted-connections-client-side-configuration) na documentação do MySQL.
Ao usar o Cliente MySQL 5.7 ou MySQL 8.0, uma conexão SSL requer verificação com base no certificado de CA de servidor se, para a opção `--ssl-mode`, você especificar `VERIFY_CA` ou `VERIFY_IDENTITY`, como no exemplo a seguir.
```
mysql -h mysql-database.rds.amazonaws.com -uadmin -ppassword --ssl-ca=/tmp/ssl-cert.pem --ssl-mode=VERIFY_CA
```
Ao usar o Cliente MySQL 5.6, uma conexão SSL exigirá verificação com base no certificado de CA de servidor se você especificar a opção `--ssl-verify-server-cert`, como no exemplo a seguir.
```
mysql -h mysql-database.rds.amazonaws.com -uadmin -ppassword --ssl-ca=/tmp/ssl-cert.pem --ssl-verify-server-cert
```
## Atualizar o armazenamento confiável de aplicações
Para obter informações sobre como atualizar o repositório confiável para aplicativos MySQL, consulte o tópico sobre como [Usar o TLS/SSL com MariaDB Connector/J](https://mariadb.com/kb/en/library/using-tls-ssl-with-mariadb-java-connector/), na documentação do MariaDB.
Para obter informações sobre como baixar o certificado raiz, consulte [Usar SSL/TLS para criptografar uma conexão com uma instância ou um cluster de banco de dados](UsingWithRDS.SSL.md).
Para obter exemplos de scripts que importam certificados, consulte [Script de exemplo para importar certificados para o seu armazenamento confiável](UsingWithRDS.SSL-certificate-rotation.md#UsingWithRDS.SSL-certificate-rotation-sample-script).
**nota**
Ao atualizar o armazenamento confiável, é possível reter certificados mais antigos, além de adicionar os novos certificados.
Se você estiver usando o driver JDBC MariaDB Connector/J em um aplicativo, defina as seguintes propriedades nesse aplicativo.
```
System.setProperty("javax.net.ssl.trustStore", certs);
System.setProperty("javax.net.ssl.trustStorePassword", "password");
```
Ao iniciar o aplicativo, defina as seguintes propriedades.
```
java -Djavax.net.ssl.trustStore=/path_to_truststore/MyTruststore.jks -Djavax.net.ssl.trustStorePassword=my_truststore_password com.companyName.MyApplication
```
**nota**
Especifique senhas diferentes dos prompts mostrados aqui como prática recomendada de segurança.
## Exemplo de código Java para estabelecer conexões SSL
O exemplo de código a seguir mostra como configurar a conexão SSL usando o JDBC.
```
private static final String DB_USER = "admin";
private static final String DB_USER = "user name";
private static final String DB_PASSWORD = "password";
// This key store has only the prod root ca.
private static final String KEY_STORE_FILE_PATH = "file-path-to-keystore";
private static final String KEY_STORE_PASS = "keystore-password";
public static void main(String[] args) throws Exception {
Class.forName("org.mariadb.jdbc.Driver");
System.setProperty("javax.net.ssl.trustStore", KEY_STORE_FILE_PATH);
System.setProperty("javax.net.ssl.trustStorePassword", KEY_STORE_PASS);
Properties properties = new Properties();
properties.put("user", DB_USER);
properties.put("password", DB_PASSWORD);
Connection connection = DriverManager.getConnection("jdbc:mysql://ssl-mariadb-public.cni62e2e7kwh.us-east-1.rds.amazonaws.com:3306?useSSL=true",properties);
Statement stmt=connection.createStatement();
ResultSet rs=stmt.executeQuery("SELECT 1 from dual");
return;
}
```
**Importante**
Depois de determinar que suas conexões com o banco de dados usam SSL/TLS e ter atualizado o armazenamento confiável de aplicações, você poderá atualizar o banco de dados para usar os certificados rds-ca-rsa2048-g1. Para obter instruções, consulte a etapa 3 em [Atualizar o certificado CA modificando a instância ou o cluster de banco de dados](UsingWithRDS.SSL-certificate-rotation.md#UsingWithRDS.SSL-certificate-rotation-updating).
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
# Melhorar a performance das consultas para o RDS para MariaDB com leituras otimizadas do Amazon RDS
É possível acelerar o processamento de consultas para o RDS para MariaDB com leituras otimizadas do Amazon RDS. Uma instância de banco de dados do RDS para MariaDB que utiliza leituras otimizadas do RDS pode obter um processamento de consultas até duas vezes mais rápido em comparação com uma instância de banco de dados que não utiliza o recurso.
**Topics**
+ [Visão geral das leituras otimizadas do RDS](#rds-optimized-reads-mariadb-overview)
+ [Casos de uso para leituras otimizadas do RDS](#rds-optimized-reads-mariadb-use-cases)
+ [Práticas recomendadas para leituras otimizadas do RDS](#rds-optimized-reads-mariadb-best-practices)
+ [Utilizar leituras otimizadas do RDS](#rds-optimized-reads-mariadb-using)
+ [Monitorar instâncias de banco de dados que utilizam leituras otimizadas do RDS](#rds-optimized-reads-mariadb-monitoring)
+ [Limitações das leituras otimizadas do RDS](#rds-optimized-reads-mariadb-limitations)
## Visão geral das leituras otimizadas do RDS
Quando você usa uma instância de banco de dados do RDS para MariaDB com leituras otimizadas do RDS ativadas, sua instância de banco de dados obtém uma performance de consulta mais rápida por meio do uso de um armazenamento de instâncias. Um *armazenamento de instâncias* fornece armazenamento temporário em nível de bloco para a instância de banco de dados. O armazenamento está localizado em unidades de estado sólido (SSDs) Non-Volatile Memory Express (NVMe) anexadas fisicamente ao servidor host. Esse armazenamento é otimizado para baixa latência, performance de E/S aleatória muito alta e alto throughput de leitura de sequencial.
As leituras otimizadas do RDS são ativadas por padrão quando uma instância de banco de dados utiliza uma classe de instância de banco de dados com um armazenamento de instâncias, como db.m5d ou db.m6gd. Com leituras otimizadas do RDS, alguns objetos temporários são armazenados no armazenamento de instâncias. Esses objetos temporários incluem arquivos temporários internos, tabelas temporárias internas em disco, arquivos de mapa de memória e arquivos de cache de log binário. Para ter mais informações sobre o armazenamento de instância, consulte [Armazenamento de instância do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html) no *Amazon Elastic Compute Cloud Manual do usuário para instâncias do Linux*.
As workloads que geram objetos temporários no MariaDB para processamento de consultas podem aproveitar o armazenamento de instâncias para acelerar o processamento das consultas. Esse tipo de workload inclui consultas que envolvem classificações, agregações de hash, uniões de alta carga, expressões de tabela comuns (CTEs) e consultas em colunas não indexadas. Esses volumes de armazenamento de instâncias oferecem um nível superior de IOPS e performance, independentemente das configurações de armazenamento utilizadas para armazenamento persistente do Amazon EBS. Como as leituras otimizadas do RDS transferem operações em objetos temporários para o armazenamento de instâncias, as operações de entrada e saída por segundo (IOPS) ou o throughput do armazenamento persistente (Amazon EBS) agora podem ser utilizadas para operações em objetos persistentes. Essas operações incluem leituras e gravações regulares de arquivos de dados e operações do mecanismo em segundo plano, como limpar e inserir mesclagens de buffer.
**nota**
Os snapshots manuais e automatizados do RDS contêm apenas arquivos de mecanismo para objetos persistentes. Os objetos temporários criados no armazenamento de instâncias não estão incluídos nos snapshots do RDS.
## Casos de uso para leituras otimizadas do RDS
Se você tem workloads que dependem muito de objetos temporários, como tabelas ou arquivos internos, para a execução de consultas, você pode se beneficiar da ativação de leituras otimizadas do RDS. Os seguintes casos de uso são candidatos para leituras otimizadas do RDS:
+ Aplicações que executam consultas analíticas com expressões de tabela comuns (CTEs) complexas, tabelas derivadas e operações de agrupamento
+ Réplicas de leitura que oferecem tráfego de leitura intenso com consultas não otimizadas
+ Aplicações que executam consultas de relatórios dinâmicos ou sob demanda que envolvem operações complexas, como consultas com as cláusulas `GROUP BY` e `ORDER BY`
+ Workloads que utilizam tabelas temporárias internas para processamento de consultas
Você pode monitorar a variável de status do mecanismo `created_tmp_disk_tables` para determinar o número de tabelas temporárias baseadas em disco criadas em sua instância de banco de dados.
+ Aplicações que criam grandes tabelas temporárias, diretamente ou em procedimentos, para armazenar resultados intermediários
+ Consultas de banco de dados que realizam agrupamento ou classificação em colunas não indexadas
## Práticas recomendadas para leituras otimizadas do RDS
Use as práticas recomendadas a seguir para leituras otimizadas do RDS:
+ Adicione uma lógica de repetição para consultas somente leitura caso elas falhem devido ao armazenamento de instância estar cheio durante a execução.
+ Monitore o espaço de armazenamento disponível no armazenamento de instâncias com a métrica do CloudWatch `FreeLocalStorage`. Se o armazenamento de instâncias estiver atingindo seu limite devido à workload na instância de banco de dados, modifique a instância de banco de dados para utilizar uma classe de instância de banco de dados maior.
+ Quando sua instância de banco de dados tiver memória suficiente, mas ainda estiver atingindo o limite de armazenamento no armazenamento de instâncias, aumente o valor `binlog_cache_size` para manter as entradas de log binário específicas da sessão na memória. Essa configuração impede a gravação das entradas de log binário em arquivos temporários de cache de log binário no disco.
O parâmetro `binlog_cache_size` é específico da sessão. É possível alterar o valor de cada nova sessão. A configuração desse parâmetro pode aumentar a utilização da memória na instância de banco de dados durante a workload de pico. Portanto, considere aumentar o valor do parâmetro com base no padrão de workload de sua aplicação e na memória disponível na instância de banco de dados.
+ Utilize o valor padrão de `MIXED` para o `binlog_format`. Dependendo do tamanho das transações, definir `binlog_format` como `ROW` pode ocasionar arquivos de cache de log binário grandes no armazenamento de instâncias.
+ Evite realizar alterações em massa em uma única transação. Esses tipos de transações podem gerar arquivos de cache de log binário grandes no armazenamento de instâncias e causar problemas quando o armazenamento de instâncias está cheio. Considere dividir as gravações em várias transações pequenas para minimizar o uso de armazenamento para arquivos de cache de log binário.
## Utilizar leituras otimizadas do RDS
Quando você provisiona uma instância de banco de dados do RDS para MariaDB com uma das seguintes classes de instância de banco de dados em uma implantação de instância de banco de dados single-AZ ou multi-AZ, a instância de banco de dados utiliza automaticamente o recurso Leituras otimizadas pelo RDS.
Para ativar as leituras otimizadas do RDS, execute um destes procedimentos:
+ Crie uma instância de banco de dados do RDS para MariaDB utilizando uma dessas classes de instância de banco de dados. Para ter mais informações, consulte [Criar uma instância de banco de dados do Amazon RDS](USER_CreateDBInstance.md).
+ Modifique uma instância de banco de dados do RDS para MariaDB para utilizar uma dessas classes de instância de banco de dados. Para ter mais informações, consulte [Modificar uma instância de banco de dados do Amazon RDS](Overview.DBInstance.Modifying.md).
O recurso Leituras otimizadas pelo RDS está disponível em todas as Regiões da AWS onde há suporte para uma ou mais dessas classes de instância de banco de dados com SSD NVMe local. Para obter informações sobre classes de instância de banco de dados, consulte [Classes de instâncias de banco de dados do ](Concepts.DBInstanceClass.md).
A disponibilidade da classe de instância de banco de dados difere em Regiões da AWS. Para determinar se uma classe de instância de banco de dados é compatível com uma Região da AWS específica, consulte [Determinar o suporte para classes de instância de bancos de dados nas Regiões da AWS](Concepts.DBInstanceClass.RegionSupport.md).
Se você não quiser utilizar leituras otimizadas do RDS, modifique sua instância de banco de dados para que ela não use uma classe de instância de banco de dados compatível com o recurso.
## Monitorar instâncias de banco de dados que utilizam leituras otimizadas do RDS
Você pode monitorar instâncias de banco de dados que utilizam leituras otimizadas do RDS com as seguintes métricas do CloudWatch:
+ `FreeLocalStorage`
+ `ReadIOPSLocalStorage`
+ `ReadLatencyLocalStorage`
+ `ReadThroughputLocalStorage`
+ `WriteIOPSLocalStorage`
+ `WriteLatencyLocalStorage`
+ `WriteThroughputLocalStorage`
Essas métricas fornecem dados sobre armazenamento de instâncias, IOPS e throughput. Para ter mais informações sobre essas métricas, consulte [Métricas específicas da instância do Amazon CloudWatch para Amazon RDS](rds-metrics.md#rds-cw-metrics-instance).
## Limitações das leituras otimizadas do RDS
As seguintes limitações se aplicam às leituras otimizadas do RDS:
+ O recurso de leituras otimizadas do RDS é compatível com as seguintes versões do RDS para MariaDB:
+ Todas as versões secundárias disponíveis da 11.4 e versões principais posteriores.
+ 10.11.4 e versões 10.11 posteriores
+ 10.6.7 e versões 10.6 posteriores
+ 10.5.16 e versões 10.5 posteriores
+ 10.4.25 e versões 10.4 posteriores
Para obter informações sobre as versões do RDS para MariaDB, consulte [MariaDB em versões do Amazon RDS](MariaDB.Concepts.VersionMgmt.md).
+ Você não pode alterar a localização de objetos temporários para armazenamento persistente (Amazon EBS) nas classes de instância de banco de dados compatíveis com leituras otimizadas do RDS.
+ Quando o registro em log binário está ativado em uma instância de banco de dados, o tamanho máximo da transação é limitado pelo tamanho do armazenamento de instância. No MariaDB, qualquer sessão que exija mais armazenamento do que o valor de `binlog_cache_size` grava alterações de transações em arquivos temporários de cache de log binário, que são criados no armazenamento de instância.
+ As transações podem falhar quando o armazenamento de instância está cheio.
# Melhorar a performance das gravações com gravações otimizadas pelo Amazon RDS para MariaDB
Você pode melhorar a performance das transações de gravação com as gravações otimizadas pelo Amazon RDS para MariaDB. Quando seu banco de dados do RDS para MariaDB usa gravações otimizadas pelo RDS, ele pode atingir um throughput de transações de gravação até duas vezes maior.
**Topics**
+ [Visão geral das gravações otimizadas pelo RDS](#rds-optimized-writes-overview)
+ [Utilizar gravações otimizadas pelo RDS](#rds-optimized-writes-using-mariadb)
+ [Habilitando gravações otimizadas para RDS em um banco de dados existente](#rds-optimized-writes-modify-enable-mariadb)
+ [Limitações das gravações otimizadas pelo RDS](#rds-optimized-writes-limitations-mariadb)
## Visão geral das gravações otimizadas pelo RDS
Quando você ativa as gravações otimizadas pelo Amazon RDS, seus bancos de dados do RDS para MariaDB gravam apenas uma vez ao liberar dados em um armazenamento durável sem a necessidade do buffer de gravação dupla. Os bancos de dados continuam fornecendo proteções de propriedade ACID para transações de banco de dados confiáveis, além de desempenho aprimorado.
Bancos de dados relacionais, como o MariaDB, fornecem as *propriedades ACID* de atomicidade, consistência, isolamento e durabilidade para transações de banco de dados confiáveis. Para ajudar a fornecer essas propriedades, o MariaDB usa uma área de armazenamento de dados denominada *buffer de gravação dupla* que evita erros parciais de gravação de página. Esses erros ocorrem quando há uma falha de hardware enquanto o banco de dados está atualizando uma página, como no caso de uma queda de energia. Um banco de dados MariaDB pode detectar gravações parciais de páginas e recuperá-las com uma cópia da página no buffer de gravação dupla. Embora essa técnica ofereça proteção, ela também ocasiona operações extras de gravação. Para ter mais informações sobre o buffer de gravação dupla do MariaDB, consulte [Buffer de gravação dupla do InnoDB](https://mariadb.com/kb/en/innodb-doublewrite-buffer/) na documentação do MariaDB.
Com as gravações otimizadas pelo RDS ativadas, os bancos de dados do RDS para MariaDB gravam apenas uma vez ao liberar dados em um armazenamento durável sem a necessidade do buffer de gravação dupla. As gravações otimizadas pelo RDS são úteis se você executa workloads de uso intenso de gravação em seus bancos de dados do RDS para MariaDB. Exemplos de bancos de dados com workloads de uso intenso de gravação incluem os compatíveis com pagamentos digitais, negociação financeira e aplicações de jogos.
Esses bancos de dados são executados em classes de instância de banco de dados que utilizam o AWS Nitro System. Devido à configuração de hardware nesses sistemas, o banco de dados pode gravar páginas de 16 KiB diretamente nos arquivos de dados de forma confiável e durável em uma única etapa. O sistema AWS Nitro possibilita gravações otimizadas pelo RDS.
Você pode definir o novo parâmetro de banco de dados `rds.optimized_writes` para controlar o recurso de gravações otimizadas pelo RDS para bancos de dados do RDS para MariaDB. Acesse esse parâmetro nos grupos de parâmetros de banco de dados do RDS para MariaDB para as seguintes versões:
+ Todas as versões secundárias disponíveis da 11.8 e versões principais posteriores.
+ 11.4.3 e versões 11.4 posteriores
+ 10.11.4 e versões 10.11 posteriores
+ 10.6.10 e versões 10.6 posteriores
Defina o parâmetro com os seguintes valores:
+ `AUTO`: ative as gravações otimizadas pelo RDS se o banco de dados for compatível com o recurso. Desative as gravações otimizadas pelo RDS se o banco de dados não for compatível com o recurso. Essa é a configuração padrão.
+ `OFF`: desative as gravações otimizadas pelo RDS mesmo se o banco de dados for compatível com o recurso.
Se você migrar um banco de dados do RDS para MariaDB configurado para usar gravações otimizadas pelo RDS para uma classe de instância de banco de dados que não seja compatível com o recurso, o RDS desativará automaticamente as gravações otimizadas pelo RDS para o banco de dados.
Quando as gravações otimizadas pelo RDS estão desativadas, o banco de dados usa o buffer de gravação dupla do MariaDB.
Para determinar se um banco de dados do RDS para MariaDB está usando gravações otimizadas pelo RDS, visualize o valor atual do parâmetro `innodb_doublewrite` para o banco de dados. Se o banco de dados estiver usando gravações otimizadas pelo RDS, esse parâmetro será definido como `FALSE` (`0`).
## Utilizar gravações otimizadas pelo RDS
Você pode ativar as gravações otimizadas pelo RDS ao criar um banco de dados do RDS para MariaDB com o console do RDS, a AWS CLI ou a API do RDS. As gravações otimizadas pelo RDS são ativadas automaticamente quando as duas condições a seguir se aplicam durante a criação do banco de dados:
+ Você especifica uma versão de mecanismo de banco de dados e uma classe de instância de banco de dados compatíveis com as gravações otimizadas pelo RDS.
+ O recurso Leituras otimizadas pelo RDS é compatível com as seguintes versões do RDS para MariaDB:
+ Todas as versões secundárias disponíveis da 11.8 e versões principais posteriores.
+ 11.4.3 e versões 11.4 posteriores
+ 10.11.4 e versões 10.11 posteriores
+ 10.6.10 e versões 10.6 posteriores
Para obter informações sobre as versões do RDS para MariaDB, consulte [MariaDB em versões do Amazon RDS](MariaDB.Concepts.VersionMgmt.md).
+ As gravações otimizadas pelo RDS são compatíveis com bancos de dados do RDS para MariaDB que usam as seguintes classes de instância de banco de dados:
+ db.m7i
+ db.m7g
+ db.m6g
+ db.m6gd
+ db.m6i
+ db.m5
+ db.m5d
+ db.r7i
+ db.r7g
+ db.r6g
+ db.r6gd
+ db.r6i
+ db.r5
+ db.r5b
+ db.r5d
+ db.x2idn
+ db.x2iedn
Para obter informações sobre classes de instância de banco de dados, consulte [Classes de instâncias de banco de dados do ](Concepts.DBInstanceClass.md).
A disponibilidade da classe de instância de banco de dados difere em Regiões da AWS. Para determinar se uma classe de instância de banco de dados é compatível com uma Região da AWS específica, consulte [Determinar o suporte para classes de instância de bancos de dados nas Regiões da AWS](Concepts.DBInstanceClass.RegionSupport.md).
+ No grupo de parâmetros associado ao banco de dados, o parâmetro `rds.optimized_writes` é definido como `AUTO`. Nos grupos de parâmetros padrão, esse parâmetro é sempre definido como `AUTO`.
Se você quiser usar uma versão do mecanismo de banco de dados e uma classe de instância de banco de dados que sejam compatíveis com gravações otimizadas pelo RDS, mas não quer usar esse recurso, especifique um grupo de parâmetros personalizado ao criar o banco de dados. Nesse grupo de parâmetros, defina o parâmetro `rds.optimized_writes` como `OFF`. Se você quiser que o banco de dados use gravações otimizadas pelo RDS posteriormente, você pode definir o parâmetro `AUTO` para ativá-lo. Para obter informações sobre como criar grupos de parâmetros personalizados e definir parâmetros, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
Para obter informações sobre como criar uma instância de banco de dados, consulte [Criar uma instância de banco de dados do Amazon RDS](USER_CreateDBInstance.md).
### Console
Ao usar o console do RDS para criar um banco de dados do RDS para MariaDB, você pode filtrar as versões do mecanismo de banco de dados e as classes de instância de banco de dados compatíveis com gravações otimizadas pelo RDS. Depois de ativar os filtros, é possível selecionar entre as versões disponíveis do mecanismo de banco de dados e classes de instância de banco de dados.
Para selecionar uma versão do mecanismo de banco de dados que seja compatível com gravações otimizadas pelo RDS, filtre as versões do mecanismo de banco de dados do RDS para MariaDB compatíveis com o recurso em **Versão do mecanismo** e, depois, selecione uma versão.
![\[A seção Opções do mecanismo com o filtro Gravações otimizadas pelo Amazon RDS ativado para a Versão do mecanismo.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/rds-optimized-writes-version-filter-mariadb.png)
Na seção **Instance configuration** (Configuração da instância), filtre as classes de instância de banco de dados que são compatíveis com gravações otimizadas pelo RDS e selecione uma classe de instância de banco de dados.
![\[A seção Configuração da instância com o filtro Gravações otimizadas pelo Amazon RDS ativado para a Classe de instância de banco de dados.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/rds-optimized-writes-class-filter.png)
Depois de fazer essas seleções, você pode selecionar outras configurações que atendam aos seus requisitos e concluir a criação do banco de dados do RDS para MariaDB com o console.
### AWS CLI
Para criar uma instância de banco de dados utilizando o comando da AWS CLI, execute o comando [create-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-instance.html). Os valores `--engine-version` e `--db-instance-class` devem ser compatíveis com gravações otimizadas pelo RDS. Além disso, verifique se o grupo de parâmetros associado a uma instância de banco de dados tem o parâmetro `rds.optimized_writes` definido como `AUTO`. O exemplo associa o grupo de parâmetros padrão à instância de banco de dados.
**Example Criar uma instância de banco de dados que utilize gravações otimizadas pelo RDS**
Para Linux, macOS ou Unix:
```
1. aws rds create-db-instance \
2. --db-instance-identifier mydbinstance \
3. --engine mariadb \
4. --engine-version 10.6.10 \
5. --db-instance-class db.r5b.large \
6. --manage-master-user-password \
7. --master-username admin \
8. --allocated-storage 200
```
Para Windows:
```
1. aws rds create-db-instance ^
2. --db-instance-identifier mydbinstance ^
3. --engine mariadb ^
4. --engine-version 10.6.10 ^
5. --db-instance-class db.r5b.large ^
6. --manage-master-user-password ^
7. --master-username admin ^
8. --allocated-storage 200
```
### API do RDS
Você pode criar uma instância de banco de dados utilizando a operação [CreateDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). Ao utilizar essa operação, os valores `EngineVersion` e `DBInstanceClass` devem ser compatíveis com gravações otimizadas pelo RDS. Além disso, verifique se o grupo de parâmetros associado a uma instância de banco de dados tem o parâmetro `rds.optimized_writes` definido como `AUTO`.
## Habilitando gravações otimizadas para RDS em um banco de dados existente
Para modificar um banco de dados do RDS for MariaDB existente para ativar as gravações otimizadas do RDS, o banco de dados deve ter sido criado com uma versão do mecanismo de banco de dados e uma classe de instância de banco de dados compatíveis. Além disso, o banco de dados deve ter sido criado *após* o lançamento do RDS Optimized Writes em 7 de março de 2023, pois a configuração necessária do sistema de arquivos subjacente é incompatível com a dos bancos de dados criados antes do lançamento. Se essas condições forem atendidas, você poderá ativar as gravações otimizadas para RDS definindo o `rds.optimized_writes` parâmetro como. `AUTO`
Se seu banco de dados *não* foi criado com uma versão de mecanismo, classe de instância ou configuração de sistema de arquivos compatível, você pode usar o RDS Blue/Green Deployments para migrar para uma configuração compatível. Ao criar a implantação azul/verde, faça o seguinte:
+ Selecione **Habilitação de gravações otimizadas no banco de dados verde** e, em seguida, especifique uma versão do mecanismo e uma classe de instância de banco de dados compatíveis com as gravações otimizadas do RDS. Para obter uma lista das versões dos mecanismos compatíveis, consulte [Utilizar gravações otimizadas pelo RDS](#rds-optimized-writes-using-mariadb).
+ Em **Armazenamento**, escolha **Atualizar a configuração do sistema de arquivos de armazenamento**. Essa opção atualiza o banco de dados para uma configuração de sistema de arquivos subjacente compatível.
Ao criar a implantação azul/verde, se o `rds.optimized_writes` parâmetro estiver definido para`AUTO`, as gravações otimizadas do RDS serão ativadas automaticamente no ambiente verde. Você pode então fazer a transição azul/verde, o que promove o ambiente verde para o novo ambiente de produção.
Para obter mais informações, consulte [Criar uma implantação azul/verde no Amazon RDS](blue-green-deployments-creating.md).
## Limitações das gravações otimizadas pelo RDS
Ao restaurar um banco de dados do RDS para MariaDB por meio de um snapshot, você só poderá ativar as gravações otimizadas pelo RDS no banco de dados se todas as condições a seguir se aplicarem:
+ O snapshot foi criado a partir de um banco de dados compatível com gravações otimizadas pelo RDS.
+ O snapshot foi criado por meio de um banco de dados criado *após* o lançamento de gravações otimizadas pelo RDS.
+ O snapshot foi restaurado a partir de um banco de dados compatível com gravações otimizadas pelo RDS.
+ O banco de dados restaurado é associado a um grupo de parâmetros que tenha o parâmetro `rds.optimized_writes` definido como `AUTO`.
# Atualizações do mecanismo de banco de dados do MariaDB
Quando o Amazon RDS oferece suporte a uma nova versão de um mecanismo de banco de dados, você pode atualizar suas instâncias de banco de dados para essa nova versão. Há dois tipos de atualizações para instâncias de banco de dados MariaDB: atualizações de versão principal e atualizações de versão secundária.
As *atualizações da versão principal* podem conter as alterações de banco de dados incompatíveis com os aplicativos existentes. Como resultado, você deve realizar manualmente as atualizações de versões principais das suas instâncias de banco de dados. Você pode iniciar uma atualização de versão principal modificando manualmente sua instância de banco de dados. No entanto, antes de realizar uma atualização de versão principal, recomendamos seguir as instruções descritas em [Atualização da versão principal do RDS para MariaDB](USER_UpgradeDBInstance.MariaDB.Major.md).
Por outro lado, *atualizações de versões secundárias* incluem apenas alterações compatíveis com versões anteriores dos aplicativos existentes. Você pode iniciar uma atualização de versão secundária manualmente modificando sua instância de banco de dados. Ou é possível habilitar a opção **Auto minor version upgrade (Atualização automática da versões secundárias)** ao criar ou modificar uma instância de banco de dados. Isso significa que sua instância de banco de dados será atualizada automaticamente depois que o Amazon RDS testar e aprovar a nova versão. Para obter informações sobre como realizar uma atualização, consulte [Atualizar a versão de mecanismo de uma instância de banco de dados ](USER_UpgradeDBInstance.Upgrading.md).
Se a instância de banco de dados MariaDB estiver usando réplicas de leitura, atualize todas as réplicas de leitura antes de atualizar a instância de origem. Se a instância de banco de dados estiver em uma implantação multi-AZ, as réplicas do gravador e em espera serão atualizadas. A instância de banco de dados pode não estar disponível até que a atualização seja concluída.
Para obter mais informações sobre as versões do MariaDB com suporte e o gerenciamento de versões, consulte [MariaDB em versões do Amazon RDS](MariaDB.Concepts.VersionMgmt.md).
As atualizações do mecanismo de banco de dados necessitam de tempo de inatividade. A duração do tempo de inatividade varia de acordo com o tamanho de sua instância de banco de dados.
O Amazon RDS também comporta a política de implementação de atualizações para gerenciar atualizações automáticas de versões secundárias em vários recursos de banco de dados e Contas da AWS. Para obter mais informações, consulte [Usar a política de implementação de atualização do AWS Organizations para atualizações automáticas de versões secundárias](RDS.Maintenance.AMVU.UpgradeRollout.md).
**dica**
Você pode minimizar o tempo de inatividade necessário para a atualização da instância de banco de dados utilizando uma implantação azul/verde. Para obter mais informações, consulte [Usar implantações azul/verde do Amazon RDS para atualizações de banco de dados](blue-green-deployments.md).
**Topics**
+ [Considerações sobre as atualizações do MariaDB](#USER_UpgradeDBInstance.MariaDB.Considerations)
+ [Encontrar destinos de atualização válidos](#USER_UpgradeDBInstance.MariaDB.FindingTargets)
+ [Números de versão do MariaDB](USER_UpgradeDBInstance.MariaDB.VersionID.md)
+ [Números de versão do RDS no RDS para MariaDB](USER_UpgradeDBInstance.MariaDB.rds.version.md)
+ [Atualização da versão principal do RDS para MariaDB](USER_UpgradeDBInstance.MariaDB.Major.md)
+ [Atualizar uma instância de banco de dados MariaDB](#USER_UpgradeDBInstance.MariaDB.Upgrading)
+ [Atualizações automáticas da versão secundária do RDS para MariaDB](USER_UpgradeDBInstance.MariaDB.Minor.md)
+ [Usar uma réplica de leitura para reduzir o tempo de inatividade ao fazer a atualização de um banco de dados do RDS para MariaDB](USER_UpgradeDBInstance.MariaDB.ReducedDowntime.md)
+ [Monitorar atualizações do mecanismo de banco de dados do RDS para MariaDB com eventos](USER_UpgradeDBInstance.MariaDB.Monitoring.md)
## Considerações sobre as atualizações do MariaDB
O Amazon RDS usa dois ou mais snapshots de banco de dados durante o processo de upgrade. O Amazon RDS gera até dois snapshots da instância de banco de dados *antes* de fazer qualquer alteração de upgrade. Se o upgrade não funcionar para seus bancos de dados, você poderá restaurar um desses snapshots para criar uma instância de banco de dados executando a versão antiga. O Amazon RDS gera outro snapshot da instância de banco de dados quando o upgrade é concluído. O Amazon RDS obtém esses snapshots independentemente de o AWS Backup gerenciar ou não os backups da instância de banco de dados.
**nota**
O Amazon RDS só tirará snapshot de banco de dadoss se você tiver definido o período de retenção de backup para sua instância de banco de dados como um número maior que 0. Para alterar o período de retenção de backup, consulte [Modificar uma instância de banco de dados do Amazon RDS](Overview.DBInstance.Modifying.md).
Após a conclusão da atualização, você não pode reverter para a versão anterior do mecanismo de banco de dados. Se quiser retornar à versão anterior, restaure o primeiro DB snapshot tirado para criar outra instância de banco de dados.
Você controla quando atualizar sua instância do banco de dados para uma nova versão compatível com o Amazon RDS. Esse nível de controle ajuda você a manter a compatibilidade com versões específicas de banco de dados e testar novas versões com seu aplicativo antes de implantá-lo na produção. Quando você estiver pronto, poderá executar as atualizações de versão quando achar melhor.
Se sua instância de banco de dados estiver usando uma replicação de leitura, atualize todas as réplicas de leitura antes de atualizar a instância de origem.
Se a sua instância de banco de dados estiver em uma implantação multi-AZ, as instâncias de banco de dados principal e em espera serão atualizadas. As instâncias de bancos de dados primária e de espera são atualizadas ao mesmo tempo, e há uma interrupção no serviço até a atualização ser concluída. O tempo para a interrupção varia de acordo com o mecanismo de banco de dados, a versão do mecanismo e o tamanho da instância de banco de dados.
## Encontrar destinos de atualização válidos
Ao usar o Console de gerenciamento da AWS para atualizar uma instância de banco de dados, ele exibe os destinos de atualização válidos para a instância de banco de dados. Também é possível executar o seguinte comando da AWS CLI para identificar os destinos de atualizações válidos para uma instância de banco de dados:
Para Linux, macOS ou Unix:
```
aws rds describe-db-engine-versions \
--engine mariadb \
--engine-version version_number \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
Para Windows:
```
aws rds describe-db-engine-versions ^
--engine mariadb ^
--engine-version version_number ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
Por exemplo, para identificar os destinos de atualização válidos de uma instância de banco de dados do MariaDB versão 10.5.17, execute o seguinte comando da AWS CLI:
Para Linux, macOS ou Unix:
```
aws rds describe-db-engine-versions \
--engine mariadb \
--engine-version 10.5.17 \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
Para Windows:
```
aws rds describe-db-engine-versions ^
--engine mariadb ^
--engine-version 10.5.17 ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
# Números de versão do MariaDB
A sequência de numeração de versões do mecanismo de banco de dados do RDS para MariaDB está no formato *major.minor.patch.YYYYMMDD* or *major.minor.patch*, por exemplo, 10.11.5.R2.20231201 ou 10.4.30. O formato usado depende da versão do mecanismo do MariaDB.
**principal**
O número da versão principal é o número inteiro e a primeira parte fracionária do número da versão, por exemplo, 10.11. Uma atualização de versão principal aumenta a parte principal do número da versão. Por exemplo, uma atualização de *10.5*.20 para 10.6.12 é uma atualização de versão principal, em que *10.5* e *10.6* são os números da versão principal.
**secundária**
O número da versão secundária é a terceira parte do número da versão, por exemplo, 5 em 10.11.5.
**patch**
O patch é a quarta parte do número da versão, por exemplo, o R2 em 10.11.5.R2. Uma versão do patch do RDS inclui correções de bugs importantes adicionadas a uma versão secundária após o lançamento.
**YYYYMMDD**
O patch é a quinta parte do número da versão, por exemplo, 20231201 em 10.11.5.R2.20231201. Uma versão da data do RDS é um patch de segurança que inclui correções de segurança importantes adicionadas a uma versão secundária após o lançamento. Ela não inclui nenhuma correção que possa mudar o comportamento de um mecanismo.
A tabela a seguir explica o esquema de nomenclatura do RDS para MariaDB versão 10.11.
| 10.11 versão secundária | Esquema da nomenclatura |
| --- | --- |
| ≥5 | Novas instâncias de banco de dados usam *major.minor.patch.YYMMDD*, por exemplo, 10.11.5.R2.20231201. As instâncias de banco de dados existentes podem usar *major.minor.patch*, por exemplo, 10.11.5.R2, até a próxima atualização de versão principal ou secundária. |
| < 5 | As instâncias de banco de dados existentes usam *major.minor.patch*, por exemplo, 10.11.4.R2. |
A tabela a seguir explica o esquema de nomenclatura do RDS para MariaDB versão 10.6.
| 10.6 versão secundária | Esquema da nomenclatura |
| --- | --- |
| ≥ 14 | Novas instâncias de banco de dados usam *major.minor.patch.YYMMDD*, por exemplo, 10.6.14.R2.20231201. As instâncias de banco de dados existentes podem usar *major.minor.patch*, por exemplo, 10.6.14.R2, até a próxima atualização de versão principal ou secundária. |
| < 14 | As instâncias de banco de dados existentes usam *major.minor.patch*, por exemplo, 10.6.13.R2. |
A tabela a seguir explica o esquema de nomenclatura do RDS para MariaDB versão 10.5.
| 10.5 versão secundária | Esquema da nomenclatura |
| --- | --- |
| ≥ 21 | Novas instâncias de banco de dados usam *major.minor.patch.YYMMDD*, por exemplo, 10.5.21.R2.20231201. As instâncias de banco de dados existentes podem usar *major.minor.patch*, por exemplo, 10.5.21.R2, até a próxima atualização de versão principal ou secundária. |
| < 21 | As instâncias de banco de dados existentes usam *major.minor.patch*, por exemplo, 10.5.20.R2. |
A tabela a seguir explica o esquema de nomenclatura do RDS para MariaDB versão 10.4.
| 10.4 versão secundária | Esquema da nomenclatura |
| --- | --- |
| ≥ 30 | Novas instâncias de banco de dados usam *major.minor.patch.YYMMDD*, por exemplo, 10.4.30.R2.20231201. As instâncias de banco de dados existentes podem usar *major.minor.patch*, por exemplo, 10.4.30.R2, até a próxima atualização de versão principal ou secundária. |
| < 30 | As instâncias de banco de dados existentes usam *major.minor.patch*, por exemplo, 10.4.29.R2. |
# Números de versão do RDS no RDS para MariaDB
Os números de versão do RDS usam o esquema de nomenclatura `major.minor.patch` ou `major.minor.patch.YYYYMMDD`. Uma versão do patch do RDS inclui correções de bugs importantes adicionadas a uma versão secundária após o lançamento. Uma versão de data do RDS (*YYMMDD*) é um patch de segurança. Um patch de segurança não inclui nenhuma correção que possa mudar o comportamento do mecanismo.
Para identificar o número da versão do Amazon RDS do banco de dados, você deve primeiro criar a extensão `rds_tools` usando o seguinte comando:
```
CREATE EXTENSION rds_tools;
```
É possível descobrir o número da versão do banco de dados do RDS para MariaDB com a seguinte consulta SQL:
```
mysql> select mysql.rds_version();
```
Por exemplo, consultar um banco de dados do RDS para MariaDB 10.6.14 exibe a seguinte saída:
```
+---------------------+
| mysql.rds_version() |
+---------------------+
| 10.6.14.R2.20231201 |
+---------------------+
1 row in set (0.01 sec)
```
# Atualização da versão principal do RDS para MariaDB
As atualizações da versão principal podem conter as alterações de banco de dados incompatíveis com as aplicações existentes. Como resultado, o Amazon RDS não aplica atualizações da versão principal automaticamente. É necessário modificar manualmente sua instância de banco de dados. Convém testar completamente qualquer atualização antes de aplicá-la às suas instâncias de produção.
**nota**
No MariaDB 11.8, o valor padrão para `require_secure_transport` agora é `1`, exigindo conexões SSL/TLS seguras. Defina como `0` se forem necessárias conexões não seguras.
O Amazon RDS oferece suporte para as seguintes atualizações in-loco para versões principais do mecanismo de banco de dados MariaDB:
+ Qualquer versão do MariaDB para o MariaDB 11.8
+ Qualquer versão do MariaDB para o MariaDB 11.4
+ Qualquer versão do MariaDB para MariaDB 10.11
+ Qualquer versão do MariaDB para MariaDB 10.6
+ MariaDB 10.4 para MariaDB 10.5
Se você estiver usando um parameter group personalizado e realizar uma atualização para uma versão principal, deverá especificar um parameter group padrão para a nova versão do mecanismo de banco de dados ou criar seu próprio parameter group personalizado para essa nova versão. Associar o novo parameter group à instância de banco de dados requer que o banco de dados seja reinicializado pelo cliente depois que a atualização terminar. O status do parameter group da instância será `pending-reboot` se a instância precisar ser reinicializada para aplicar as alterações do parameter group. O status do grupo de parâmetros de uma instância pode ser visualizado no Console de gerenciamento da AWS ou executando uma chamada “describe”, como `describe-db-instances`.
## Atualizar uma instância de banco de dados MariaDB
Para obter informações sobre como atualizar manual ou automaticamente uma instância de banco de dados MariaDB, consulte [Atualizar a versão de mecanismo de uma instância de banco de dados ](USER_UpgradeDBInstance.Upgrading.md).
# Atualizações automáticas da versão secundária do RDS para MariaDB
Se você especificar as seguintes configurações ao criar ou modificar uma instância de banco de dados, poderá fazer com que sua instância de banco de dados seja atualizada automaticamente.
+ A configuração **Auto minor version upgrade (Atualização automática de versão secundária)** está habilitada.
+ A configuração **Backup retention period (Período de retenção de backup)** é maior que 0.
No Console de gerenciamento da AWS, essas configurações estão em **Additional configuration** (Configuração adicional). A imagem a seguir mostra a configuração **Auto minor version upgrade** (Atualização automática para versão secundária).
![\[Auto minor version upgrade (Atualização automática para versão secundária)\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/amvu.png)
Para ter mais informações sobre essas configurações, consulte [Configurações para instâncias de banco de dados](USER_ModifyInstance.Settings.md).
Para algumas versões principais do RDS para MariaDB em algumas Regiões da AWS, uma versão secundária é designada pelo RDS como a versão de atualização automática. Depois que uma versão secundária foi testada e aprovada pelo Amazon RDS, a atualização de versão secundária ocorre automaticamente durante a janela de manutenção. O RDS não define automaticamente versões secundárias lançadas mais recentemente como a versão de atualização automática. Antes de o RDS designar uma versão de atualização automática, diversos critérios são considerados, como estes:
+ Problemas de segurança conhecidos
+ Bugs no MariaDB edição da comunidade
+ Estabilidade geral de frota desde que a versão secundária foi lançada.
**nota**
O suporte para o uso do TLS nas versões 1.0 e 1.1 foi removido a partir de versões secundárias específicas do MariaDB. Consulte informações sobre as versões secundárias compatíveis do MariaDB em [Suporte de SSL/TLS para instâncias de banco de dados do MariaDB no Amazon RDS](MariaDB.Concepts.SSLSupport.md).
É possível executar o comando da AWS CLI a seguir para determinar a versão atual secundária de destino de atualização automática para uma versão secundária do MariaDB especificada em uma Região da AWS específica.
Para Linux, macOS ou Unix:
```
aws rds describe-db-engine-versions \
--engine mariadb \
--engine-version minor_version \
--region region \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" \
--output text
```
Para Windows:
```
aws rds describe-db-engine-versions ^
--engine mariadb ^
--engine-version minor_version ^
--region region ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" ^
--output text
```
Por exemplo, o seguinte comando da AWS CLI determina o destino da atualização secundária automática para a versão secundária 10.5.16 do MariaDB na Região da AWS Leste dos EUA (Ohio) (us-east-2).
Para Linux, macOS ou Unix:
```
aws rds describe-db-engine-versions \
--engine mariadb \
--engine-version 10.5.16 \
--region us-east-2 \
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" \
--output table
```
Para Windows:
```
aws rds describe-db-engine-versions ^
--engine mariadb ^
--engine-version 10.5.16 ^
--region us-east-2 ^
--query "DBEngineVersions[*].ValidUpgradeTarget[*].{AutoUpgrade:AutoUpgrade,EngineVersion:EngineVersion}" ^
--output table
```
A saída é semelhante à seguinte.
```
----------------------------------
| DescribeDBEngineVersions |
+--------------+-----------------+
| AutoUpgrade | EngineVersion |
+--------------+-----------------+
| True | 10.5.17 |
| False | 10.5.18 |
| False | 10.5.19 |
| False | 10.6.5 |
| False | 10.6.7 |
| False | 10.6.8 |
| False | 10.6.10 |
| False | 10.6.11 |
| False | 10.6.12 |
+--------------+-----------------+
```
Neste exemplo, o valor de `AutoUpgrade` é `True` para MariaDB versão 10.5.17. Então, o destino da atualização secundária automática é MariaDB versão 10.5.17, que está destacado na saída.
Uma instância de banco de dados MariaDB é atualizada automaticamente durante a janela de manutenção, caso os seguintes critérios sejam atendidos:
+ A configuração **Auto minor version upgrade (Atualização automática de versão secundária)** está habilitada.
+ A configuração **Backup retention period (Período de retenção de backup)** é maior que 0.
+ A instância de banco de dados está executando uma versão de mecanismo de banco de dados secundária que é menor que a versão secundária de atualização automática.
Para obter mais informações, consulte [Atualizar automaticamente a versão do mecanismo espelho](USER_UpgradeDBInstance.Upgrading.md#USER_UpgradeDBInstance.Upgrading.AutoMinorVersionUpgrades).
# Usar uma réplica de leitura para reduzir o tempo de inatividade ao fazer a atualização de um banco de dados do RDS para MariaDB
Na maioria dos casos, uma implantação azul/verde é a melhor opção para reduzir o tempo de inatividade ao atualizar uma instância de banco de dados MariaDB. Para ter mais informações, consulte [Usar implantações azul/verde do Amazon RDS para atualizações de banco de dados](blue-green-deployments.md).
Se não for possível usar uma implantação azul/verde e se sua instância de banco de dados MariaDB estiver em uso com uma aplicação de produção, você poderá usar o procedimento a seguir para atualizar a versão de banco de dados da sua instância de banco de dados. Esse procedimento pode reduzir o tempo de inatividade do seu aplicativo.
Usando uma réplica de leitura, você pode executar a maioria das etapas de manutenção antes do tempo e minimizar as alterações necessárias durante a interrupção real. Com essa técnica, você pode testar e preparar a nova instância de banco de dados sem fazer alterações em sua instância de banco de dados existente.
O procedimento a seguir mostra um exemplo de atualização do MariaDB versão 10.5 para o MariaDB versão 10.6. Você pode usar as mesmas etapas gerais nas atualizações para outras versões principais.
**Como atualizar um banco de dados MariaDB enquanto uma instância de banco de dados está em uso**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. Crie uma réplica de leitura de sua instância de banco de dados do MariaDB 10.5. Esse processo cria uma cópia atualizável do seu banco de dados. Outras réplicas de leitura da instância de banco de dados também podem existir.
1. No console, escolha **Databases (Bancos de dados)** e depois escolha a instância de banco de dados que você deseja atualizar.
1. Em **Actions (Ações)**, escolha **Create read replica (Criar réplica de leitura)**.
1. Forneça o valor do **DB instance identifier** (Identificador de instância de banco de dados) para a réplica de leitura e verifique se a **DB instance class** (Classe da instância de banco de dados) e as outras configurações correspondem à instância de banco de dados MariaDB 10.5.
1. Escolha **Create read replica (Criar réplica de leitura)**.
1. (Opcional) Quando a réplica de leitura for criada e **Status** for exibida **Available (Disponível)**, converta a réplica de leitura em uma implantação multi-AZ e ative backups.
Por padrão, uma réplica de leitura é criada como uma implantação single-AZ com backups desativados. Como a réplica de leitura se torna a instância de banco de dados de produção, uma prática recomendada é configurar uma implantação multi-AZ e habilitar backups agora.
1. No console, selecione **Databases (Bancos de dados)** e a réplica de leitura que você acabou de criar.
1. Selecione **Modify**.
1. Para **Multi-AZ deployment (Implantação multi-AZ)**, escolha **Create a standby instance (Criar uma instância em espera)**.
1. Em **Backup Retention Period** (Período de retenção de backup), escolha um valor positivo diferente de zero, como 3 dias, depois selecione **Continue** (Continuar).
1. Em **Scheduling of modifications (Programação de modificações)**, selecione **Apply immediately (Aplicar imediatamente)**.
1. Selecione **Modify DB instance (Modificar instância de banco de dados)**.
1. Quando o **Status** da réplica de leitura mostrar **Available** (Disponível), atualize a réplica de leitura para o MariaDB 10.6.
1. No console, selecione **Databases (Bancos de dados)** e a réplica de leitura que você acabou de criar.
1. Selecione **Modify**.
1. Em **DB engine version** (Versão do mecanismo de banco de dados), selecione a versão do MariaDB 10.6 para a qual deseja atualizar, depois escolha **Continue** (Continuar).
1. Em **Scheduling of modifications (Programação de modificações)**, selecione **Apply immediately (Aplicar imediatamente)**.
1. Selecione **Modify DB instance (Modificar instância de banco de dados)** para iniciar a atualização.
1. Quando a atualização for concluída e o **Status** mostrar **Available** (Disponível), verifique se a réplica de leitura está atualizada em relação à instância de banco de dados MariaDB 10.5 de origem. Para verificar, conecte-se à réplica de leitura e execute o comando `SHOW REPLICA STATUS`. Se o campo `Seconds_Behind_Master` for `0`, a replicação está atualizada.
**nota**
Versões anteriores do MariaDB usavam `SHOW SLAVE STATUS` em vez de `SHOW REPLICA STATUS`. Se você estiver usando uma versão do MariaDB anterior à 10.6, use `SHOW SLAVE STATUS`.
1. (Opcional) Crie uma réplica de leitura da réplica de leitura.
Se você quiser que a instância de banco de dados tenha uma réplica de leitura depois que ela for promovida para uma instância de banco de dados autônoma, você pode criar a réplica de leitura agora.
1. No console, selecione **Databases (Bancos de dados)** e selecione a réplica de leitura que você acabou de atualizar.
1. Em **Actions (Ações)**, escolha **Create read replica (Criar réplica de leitura)**.
1. Forneça o valor do **DB instance identifier** (Identificador de instância de banco de dados) para a réplica de leitura e verifique se a **DB instance class** (Classe da instância de banco de dados) e as outras configurações correspondem à instância de banco de dados MariaDB 10.5.
1. Escolha **Create read replica (Criar réplica de leitura)**.
1. (Opcional) Configure um grupo de parâmetros de banco de dados personalizado para a réplica de leitura.
Se você quiser que a instância de banco de dados use um grupo de parâmetros personalizado depois de ser promovida para uma instância de banco de dados autônoma, poderá criar o grupo de parâmetros de banco de dados agora pode associá-lo à réplica de leitura.
1. Crie um grupo de parâmetros de banco de dados personalizado para o MariaDB 10.6. Para obter instruções, consulte [Criar um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Creating.md).
1. Modifique os parâmetros que você deseja alterar no grupo de parâmetros de banco de dados que você acabou de criar. Para obter instruções, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md).
1. No console, selecione **Databases (Bancos de dados)** e a réplica de leitura.
1. Selecione **Modify**.
1. Em **DB parameter group** (Grupo de parâmetros do banco de dados), escolha o grupo de parâmetros do banco de dados MariaDB 10.6 que você acabou de criar, depois selecione **Continue** (Continuar).
1. Em **Scheduling of modifications (Programação de modificações)**, selecione **Apply immediately (Aplicar imediatamente)**.
1. Selecione **Modify DB instance (Modificar instância de banco de dados)** para iniciar a atualização.
1. Torne sua réplica de leitura do MariaDB 10.6 uma instância de banco de dados autônoma.
**Importante**
Quando você promove a réplica de leitura do MariaDB 10.6 para uma instância de banco de dados autônoma, ela deixa de ser uma réplica da instância de banco de dados MariaDB 10.5. Recomendamos que você promova a réplica de leitura do MariaDB 10.6 durante uma janela de manutenção, quando a instância de banco de dados MariaDB 10.5 de origem estiver no modo somente leitura e todas as operações de gravação estiverem suspensas. Quando a promoção terminar, você poderá direcionar suas operações de gravação para a instância de banco de dados MariaDB 10.6 atualizada, para garantir que nenhuma operação de gravação seja perdida.
Além disso, recomendamos que, antes de promover a réplica de leitura do MariaDB 10.6, você realize todas as operações de DDL (linguagem de definição de dados) necessárias na réplica de leitura do MariaDB 10.6. Um exemplo é a criação de índices. Essa abordagem evita efeitos negativos sobre a performance da réplica de leitura do MariaDB 10.6 depois da promoção. Para promover uma réplica de leitura, use o procedimento a seguir.
1. No console, selecione **Databases (Bancos de dados)** e selecione a réplica de leitura que você acabou de atualizar.
1. Em **Actions (Ações)**, selecione **Promote (Promover)**.
1. Selecione **Yes (Sim)** para habilitar backups automatizados da instância da réplica de leitura. Para obter mais informações, consulte [Introdução aos backups](USER_WorkingWithAutomatedBackups.md).
1. Escolha **Continue**.
1. Escolha **Promote Read Replica (Promover réplica de leitura)**.
1. Agora, você possui uma versão atualizada do seu banco de dados MariaDB. Neste ponto, você pode direcionar as aplicações para a nova instância de banco de dados MariaDB 10.6.
# Monitorar atualizações do mecanismo de banco de dados do RDS para MariaDB com eventos
Quando você atualiza a versão do mecanismo de um banco de dados RDS para MariaDB, o Amazon RDS emite um evento específico durante cada fase do processo. Para acompanhar o progresso de uma atualização, você pode visualizar ou assinar esses eventos.
Para acessar mais informações sobre eventos do RDS, consulte [Monitorar eventos do Amazon RDS](working-with-events.md).
Para acessar informações detalhadas sobre um evento específico do Amazon RDS ocorrido durante a atualização do seu mecanismo, consulte [Categorias de eventos e mensagens de eventos ](USER_Events.Messages.md).
# Atualizar uma versão do mecanismo de snapshot de banco de dados do MariaDB
Com o Amazon RDS, você pode criar um snapshot de banco de dados do volume de armazenamento da instância de banco de dados do MariaDB. Ao criar um snapshot de banco de dados, ele é baseado na versão do mecanismo usada pela instância de banco de dados. É possível fazer a atualização da versão do mecanismo para os snapshots de banco de dados.
No caso do RDS para MariaDB, você pode atualizar para todas as versões de mecanismo disponíveis. É possível atualizar snapshots de banco de dados criptografados ou não criptografados.
Para visualizar as versões de mecanismo disponíveis para o snapshot de banco de dados do RDS para MariaDB, use o exemplo da AWS CLI a seguir.
```
aws rds describe-db-engine-versions --engine mariadb --include-all --engine-version example-engine-version --query "DBEngineVersions[*].ValidUpgradeTarget[*].{EngineVersion:EngineVersion}" --output text
```
Se você não vir resultados para o snapshot, a versão do seu mecanismo pode estar obsoleta. Se a versão do mecanismo tiver sido descontinuada, recomendamos que você atualize para o destino de atualização da versão principal mais recente ou para um dos outros destinos de atualização disponíveis para essa versão. Para obter mais informações, consulte [Opções de atualização para snapshots de banco de dados com versões de mecanismo incompatíveis para o RDS para MariaDB](mariadb-upgrade-snapshot.upgrade-options.md).
Após restaurar um snapshot de banco de dados atualizado para uma nova versão do mecanismo, certifique-se de testar se a atualização foi bem-sucedida. Para obter mais informações sobre uma atualização de versão principal, consulte [Atualizações do mecanismo de banco de dados do MariaDB](USER_UpgradeDBInstance.MariaDB.md). Para saber como restaurar um snapshot de banco de dados, consulte [Restaurar uma instância de banco de dados](USER_RestoreFromSnapshot.md).
**nota**
Não é possível atualizar snapshots de banco de dados automatizados criados durante o processo de backup automatizado.
É possível atualizar um snapshot de banco de dados usando o Console de gerenciamento da AWS, a AWS CLI ou a API do RDS.
------
#### [ Console ]
Para atualizar uma versão do mecanismo de snapshot de banco de dados usando o Console de gerenciamento da AWS, use o procedimento a seguir.
**Para atualizar um snapshot de banco de dados**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação, selecione **Snapshots**.
1. Escolha o snapshot que você deseja atualizar.
1. Em **Actions (Ações)**, selecione **Upgrade snapshot (Atualizar snapshot)**. A página **Upgrade snapshot (Atualizar snapshot)** é exibida.
1. Escolha a opção **New engine version (Nova versão de mecanismo)** para a qual atualizar.
1. Escolha **Save changes (Salvar alterações)** para atualizar o snapshot.
Durante o processo de atualização, todas as ações do snapshot serão desabilitadas para esse snapshot de banco de dados. Além disso, o status do snapshot de banco de dados muda de **Disponível** para **Fazendo upgrade** e, depois, muda para **Ativo** após a conclusão. Se não for possível atualizar o snapshot de banco de dados devido a problemas de corrupção do snapshot, o status mudará para **Indisponível**. Não é possível recuperar o snapshot desse estado.
**nota**
Se a atualização do snapshot de banco de dados falhar, o snapshot será revertido para o estado original com a versão original.
------
#### [ AWS CLI ]
Para atualizar um snapshot de banco de dados para uma nova versão do mecanismo de banco de dados, execute o comando [modify-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-snapshot.html) da AWS CLI.
**Opções**
+ `--db-snapshot-identifier` – o identificador do snapshot de banco de dados a ser atualizado. O identificador deve ser um nome de recurso da Amazon (ARN) exclusivo. Para obter mais informações, consulte [Nomes de recurso da Amazon (ARNs) no Amazon RDS](USER_Tagging.ARN.md).
+ `--engine-version` – a versão do mecanismo para a qual será feita a atualização do snapshot de banco de dados.
**Example**
Para Linux, macOS ou Unix:
```
1. aws rds modify-db-snapshot \
2.
3. --db-snapshot-identifier my_db_snapshot \
4. --engine-version new_version
```
Para Windows:
```
1. aws rds modify-db-snapshot ^
2. --db-snapshot-identifier my_db_snapshot ^
3. --engine-version new_version
```
------
#### [ Amazon RDS API ]
Para atualizar um snapshot de banco de dados para uma nova versão do mecanismo de banco de dados, chame a operação [ModifyDBSnapshot](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBSnapshot.html) da API do RDS.
**Parâmetros**
+ `DBSnapshotIdentifier` – o identificador do snapshot de banco de dados a ser atualizado. O identificador deve ser um nome de recurso da Amazon (ARN) exclusivo. Para obter mais informações, consulte [Nomes de recurso da Amazon (ARNs) no Amazon RDS](USER_Tagging.ARN.md).
+ `EngineVersion` – a versão do mecanismo para a qual será feita a atualização do snapshot de banco de dados.
------
# Opções de atualização para snapshots de banco de dados com versões de mecanismo incompatíveis para o RDS para MariaDB
A tabela a seguir mostra para quais versões do mecanismo é possível fazer a atualização de uma versão de mecanismo incompatível com snapshots de banco de dados do RDS para MariaDB.
**nota**
Talvez você precise atualizar o snapshot de banco de dados mais de uma vez para fazer a atualização para a versão do mecanismo escolhida.
| Versão do mecanismo do snapshot de banco de dados | Versões do mecanismo disponíveis para atualização |
| --- | --- |
| 10.0.17, 10.0.24, 10.0.28, 10.0.31, 10.0.32, 10.0.34, 10.0.35 | 10.0.38, 10.1.48, 10.6.19, 10.6.20, 10.11.9, 10.11.10, 11.4.3, 11.4.4, 11.8.3 |
| 10.1.14, 10.1.16, 10.1.19, 10.1.23, 10.1.26, 10.1.31, 10.1.34 | 10.1.48, 10.2.44, 10.6.19, 10.6.20, 10.11.9, 10.11.10, 11.4.3, 11.4.4, 11.8.3 |
| 10.2.11, 10.2.12, 10.2.15, 10.2.21, 10.2.32, 10.2.37, 10.2.39, 10.2.40, 10.2.41, 10.2.43 | 10.2.44, 10.3.39, 10.6.19, 10.6.20, 10.6.21, 10.11.9, 10.11.10, 10.11.11, 11.4.3, 11.4.4, 11.8.3 |
| 10.3.8, 10.3.13, 10.3.20, 10.3.23, 10.3.28, 10.3.31, 10.3.32 | 10.3.39, 10.4.34, 10.6.19, 10.6.20 10.6.21, 10.11.9, 10.11.10, 10.11.11, 11.4.3, 11.4.4, 11.8.3 |
| 10.4.8 | 10.4.34, 10.5.16, 10.5.17, 10.5.18, 10.5.20, 10.5.21, 10.5.22, 10.5.23, 10.5.24, 10.5.25, 10.5.26, 10.5.27, 10.5.28, 10.6.8, 10.6.10, 10.6.11, 10.6.13, 10.6.14, 10.6.15, 10.6.16, 10.6.18, 10.6.19, 10.6.20, 10.6.21, 10.11.4, 10.6.17, 10.11.5, 10.11.6, 10.11.7, 10.11.8, 10.11.9, 10.11.10, 10.11.11 |
# Importar dados para uma instância de banco de dados do Amazon RDS para MariaDB
Você pode usar várias técnicas diferentes para importar os dados para uma instância de banco de dados do RDS para MariaDB. A melhor abordagem depende de inúmeros fatores:
+ origem dos dados;
+ Quantidade de dados
+ importação única ou contínua;
+ quantidade de tempo de inatividade.
Se você também estiver migrando uma aplicação com os dados, é importante considerar a quantidade de tempo de inatividade.
A tabela a seguir lista técnicas para importar dados em uma instância de banco de dados do RDS para MariaDB.
**nota**
O Amazon RDS não aceita `mariadb-backup` nem importação do Amazon S3 para MariaDB.
| Origem | Quantidade de dados | Uma vez ou contínuo | Tempo de inatividade da aplicação | Técnica | Mais informações |
| --- | --- | --- | --- | --- | --- |
| Banco de dados do MariaDB existente on-premises ou no Amazon EC2 | Any | Contínuo | Mínimo | Configure a replicação com um banco de dados MariaDB existente como origem da replicação. É possível configurar a replicação em uma instância de banco de dados do MariaDB usando identificadores de transações globais (GTIDs) do MariaDB quando a instância externa for o MariaDB versão 10.0.24 ou posterior, ou usando coordenadas de log binário para instâncias do MariaDB em versões anteriores à 10.0.24. Os GTIDs do MariaDB são implantados de forma diferente dos GTIDs do MySQL, os quais não são compatíveis com o Amazon RDS. | [Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa](MySQL.Procedural.Importing.External.ReplMariaDB.md) [Importar dados para uma instância de banco de dados do Amazon RDS para MariaDB com tempo de inatividade reduzido](mariadb-importing-data-reduced-downtime.md) |
| Qualquer banco de dados existente | Quaisquer | Uma vez ou contínuo | Mínimo | Use o AWS Database Migration Service para migrar o banco de dados com o mínimo de tempo de inatividade e, para diversos mecanismos de banco de dados (DB), continuar a replicação contínua. | [What is AWS Database Migration Service](https://docs.aws.amazon.com/dms/latest/userguide/Welcome.html) (O que é o ) e [Using a MySQL-compatible database as a target for AWS DMS](https://docs.aws.amazon.com/dms/latest/userguide/CHAP_Target.MySQL.html) (Usar um banco de dados compatível com MySQL como destino para o ) no *Guia do usuário do AWS Database Migration Service* |
| Instância de banco de dados MariaDB existente | Any | Uma vez ou contínuo | Mínimo | Crie uma réplica de leitura para a replicação contínua. Promova a réplica de leitura para a criação única de uma instância de banco de dados. | [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md) |
| Banco de dados existente do MariaDB | Pequeno | Uma vez | Alguns | Copie os dados diretamente para a instância de banco de dados do MariaDB usando um utilitário da linha de comando. | [Importar dados de um banco de dados externo do MariaDB para uma instância de banco de dados do Amazon RDS para MariaDB](mariadb-importing-data-external-database.md) |
| Dados não armazenados em um banco de dados existente | Médio | Uma vez | Alguns | Crie arquivos simples e importe-os usando instruções `LOAD DATA LOCAL INFILE` do MariaDB. | [Importar dados de qualquer fonte para uma instância de banco de dados do Amazon RDS para MariaDB](mariadb-importing-data-any-source.md) |
**nota**
O banco de dados do sistema `mysql` contém informações de autenticação e autorização necessárias para fazer login na instância de banco de dados e acessar os dados. Descartar, alterar, renomear ou truncar tabelas, dados ou outros conteúdos do banco de dados `mysql` na instância de banco de dados pode resultar em erros e pode tornar a instância de banco de dados e os dados inacessíveis. Se isso ocorrer, você poderá restaurar a instância de banco de dados por meio de um snapshot usando o comando [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) da AWS CLI. É possível recuperar a instância de banco de dados usando o comando [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-to-point-in-time.html).
# Considerações sobre a importação de dados para o MariaDB
O conteúdo a seguir apresenta informações técnicas relacionadas ao carregamento de dados no MariaDB. Este conteúdo é destinado a usuários que estão familiarizados com a arquitetura do servidor MariaDB.
## registro em log binário
A habilitação do registro em log binário reduz a performance do carregamento de dados e requer até quatro vezes mais espaço em disco em comparação com o registro em log desabilitado. O tamanho da transação usada para carregar os dados afeta diretamente a performance do sistema e as necessidades de espaço em disco. As transações maiores exigem mais recursos.
## Tamanho da transação
O tamanho da transação influencia os seguintes aspectos dos carregamentos de dados do MariaDB:
+ Consumo de recursos
+ Utilização de espaço em disco
+ Processo de retomada
+ Tempo de recuperação
+ Formato de entrada (arquivos simples ou SQL)
Esta seção descreve como o tamanho da transação afeta o registro em log binário e justifica a desabilitação do registro em log binário durante grandes cargas de dados. Você pode habilitar e desabilitar o registro em log binário configurando o período de retenção de backup automatizado do Amazon RDS. Valores diferentes de zero habilitam o registro em log binário, enquanto um valor de zero o desabilita. Para obter mais informações, consulte [Período de retenção de backup](USER_WorkingWithAutomatedBackups.BackupRetention.md).
Esta seção descreve também o impacto de grandes transações sobre o InnoDB e por que é importante que o tamanho das transações seja pequeno.
### Transações pequenas
Para pequenas transações, o registro em log binário duplica o número de gravações em disco necessárias para carregar os dados. Esse efeito pode degradar severamente a performance de outras sessões de banco de dados e aumentar o tempo necessário para carregar os dados. A degradação experimentada depende em parte dos seguintes fatores:
+ Taxa de upload
+ Outra atividade do banco de dados que ocorre durante o carregamento
+ Capacidade da instância de banco de dados do Amazon RDS
Os logs binários também consomem um espaço em disco aproximadamente igual à quantidade de dados carregados enquanto os logs são copiados e removidos. O Amazon RDS minimiza isso fazendo backup e removendo os logs binários com frequência.
### Transações grandes
Quanto a transações grandes, o registro em log binário triplica as IOPS e o uso do disco pelos seguintes motivos:
+ O cache de log binário armazena os dados da transação temporariamente no disco.
+ Esse cache se amplia de acordo com o tamanho da transação, o que consome espaço em disco.
+ Quando a transação (de confirmação ou reversão) é concluída, o sistema copia o cache para o log binário.
Esse processo cria três cópias dos dados:
+ os dados originais;
+ o cache no disco;
+ a entrada final do log binário.
Cada operação de gravação incorre em E/S adicional, afetando ainda mais a performance.
Por isso, o registro em log binário requer o triplo de espaço em disco em comparação com o registro desabilitado. Por exemplo, carregar 10 GiB de dados como uma única transação cria três cópias:
+ 10 GiB para os dados da tabela;
+ 10 GiB para o cache de log binário;
+ 10 GiB para o arquivo de log binário.
O total de espaço em disco temporário necessário é 30 GiB.
Considerações importantes sobre o espaço em disco:
+ O arquivo de cache persiste até que a sessão termine ou uma nova transação crie outro cache.
+ O log binário permanece até o momento em que ele é copiado, possivelmente mantendo 20 GiB (cache e log) por um período prolongado.
Se você usar `LOAD DATA LOCAL INFILE` para carregar os dados, a recuperação de dados criará uma quarta cópia caso o banco de dados tenha que ser recuperado de um backup feito antes do carregamento. Durante a recuperação, o MariaDB extrai dados de log binário em um arquivo simples. Em seguida, o MariaDB executa `LOAD DATA LOCAL INFILE`. Com base no exemplo anterior, essa recuperação requer um total de espaço em disco temporário de 40 GiB ou 10 GiB cada para tabela, cache, log e arquivo local. Sem pelo menos 40 GiB de espaço livre em disco, a recuperação falhará.
### Otimizar grandes carregamentos de dados
No caso de grandes carregamentos de dados, desabilite o registro em log binário para reduzir os custos indiretos e os requisitos de espaço em disco. Você pode desabilitar o registro em log binário definindo o período de retenção de backup como 0. Após o término do carregamento, substitua o período de retenção de backup por um valor apropriado diferente de zero. Para ter mais informações, consulte [Modificar uma instância de banco de dados do Amazon RDS](Overview.DBInstance.Modifying.md) e [Período de retenção de backup](USER_ModifyInstance.Settings.md) na tabela de configurações.
**nota**
Se a instância de banco de dados for uma instância de banco de dados de origem para réplicas de leitura, não será possível definir o período de retenção de backup como 0.
Antes de carregar os dados, recomendamos criar um snapshot do banco de dados. Para obter mais informações, consulte [Gerenciar backups manuais](USER_ManagingManualBackups.md).
## InnoDB
As informações a seguir sobre o registro em log de desfazer e as opções de recuperação ajudam a manter as transações do InnoDB pequenas para otimizar a performance do banco de dados.
### Conceitos básicos sobre o registro em log de desfazer no InnoDB
Desfazer é um mecanismo de registro em log que permite a reversão de transações e comporta o controle de simultaneidade de várias versões (MVCC).
Para o MariaDB 10.11 e versões anteriores, os logs de desfazer são armazenados no espaço de tabela do sistema InnoDB (geralmente ibdata1) e são retidos até que o thread de limpeza os remova. Por esse motivo, grandes transações de carregamento de dados podem fazer com que o espaço de tabela do sistema se torne muito grande e consuma espaço em disco que não pode ser recuperado sem recriar o banco de dados.
Para todas as versões do MariaDB, o thread de limpeza só deve remover quaisquer logs de desfazer depois que a transação ativa mais antiga for confirmada ou revertida. Se o banco de dados estiver processando outras transações durante o carregamento, os logs de desfazer também se acumularão e não poderão ser removidos, mesmo que as transações sejam confirmadas e nenhuma outra precise dos logs de desfazer para o MVCC. Nessa situação, todas as transações, incluindo as transações somente leitura, ficam mais lentas. Essa desaceleração ocorre porque todas as transações acessam todas as linhas que qualquer transação, não apenas a transação de carregamento, altera. Na prática, as transações devem examinar os logs de desfazer cuja eliminação foi impedida pelas transações de carregamento de longa duração durante uma limpeza de logs de desfazer. Isso afeta a performance de qualquer operação que acesse linhas modificadas.
### Opções de recuperação de transações do InnoDB
Embora o InnoDB otimize as operações de confirmação, a reversão de grandes transações é lenta. Para uma recuperação mais rápida, execute uma recuperação para um ponto no tempo ou restaure um snapshot do banco de dados. Para obter mais informações, consulte [Recuperação para um ponto no tempo](USER_PIT.md) e [Restaurar uma instância de banco de dados](USER_RestoreFromSnapshot.md).
## Formatos de importação de dados
O MariaDB aceita dois formatos de importação de dados: arquivos simples e SQL. Analise as informações sobre cada formato para determinar a melhor opção para suas necessidades.
### Arquivos simples
Para transações pequenas, carregue arquivos simples com `LOAD DATA LOCAL INFILE`. Esse formato de importação de dados pode oferecer os seguintes benefícios em relação ao uso do SQL:
+ regras de tráfego de rede;
+ custos de transmissão de dados mais baixos;
+ redução dos custos indireto de processamento do banco de dados;
+ processamento de fluxos.
`LOAD DATA LOCAL INFILE` carrega todo o arquivo simples como uma única transação. Mantenha os arquivos individuais com um tamanho pequeno para obter as seguintes vantagens:
+ **Capacidade de retomar**: é fácil manter o controle de quais arquivos foram carregados. Se surgir um problema durante o carregamento, você poderá continuar de onde parou. Você pode precisar retransmitir alguns dados ao Amazon RDS, mas, com arquivos pequenos, a quantidade retransmitida é mínima.
+ **Carregamento de dados em paralelo**: se você tiver IOPS e largura de banda da rede suficientes para carregamento de um único arquivo, o carregamento em paralelo pode economizar tempo.
+ **Controle da taxa de carregamento**: se o carregamento de dados tiver um impacto negativo em outros processos, você poderá controlar a taxa de carregamento aumentando o intervalo entre os arquivos.
Grandes transações reduzem os benefícios de usar `LOAD DATA LOCAL INFILE` para importar dados. Quando você não conseguir dividir uma grande quantidade de dados em arquivos menores, considere a possibilidade de usar o SQL.
### SQL
O SQL tem uma vantagem fundamental em relação aos arquivos simples: é fácil manter as transações com um tamanho pequeno. Contudo, o tempo de carregamento do SQL pode ser significativamente mais longo do que o dos arquivos simples. Além disso, após uma falha, pode ser difícil determinar onde retomar. Não é possível reiniciar os arquivos mariadb-dump. Se ocorrer uma falha ao carregar um arquivo mariadb-dump, você deve modificá-lo ou substituí-lo para que o carregamento possa continuar. Ou, alternativamente, depois de corrigir a causa da falha, você pode restaurar para o ponto no tempo anterior ao carregamento e reenviar o arquivo. Para obter mais informações, consulte [Recuperação para um ponto no tempo](USER_PIT.md).
## Usar snapshots de banco de dados do Amazon RDS para pontos de verificação de banco de dados
Se você carrega dados por longos períodos, como horas ou dias, sem registro em log binário, use snapshots de banco de dados para oferecer pontos de verificação periódicos em prol da segurança dos dados. Cada snapshot de banco de dados cria uma cópia consistente da instância de banco de dados, que serve como ponto de recuperação durante falhas do sistema ou eventos de corrupção de dados. Como os snapshots de banco de dados são rápidos, os pontos de verificação frequentes têm um impacto mínimo na performance do carregamento. Você pode excluir snapshots de banco de dados anteriores sem afetar a durabilidade ou os recursos de recuperação do banco de dados. Para ter mais informações sobre snapshots de banco de dados, consulte [Gerenciar backups manuais](USER_ManagingManualBackups.md).
## Reduzir os tempos de carregamento do banco de dados
Os seguintes itens são dicas adicionais para reduzir os tempos de carregamento:
+ Crie todos os índices secundários antes de carregar dados em bancos de dados do MariaDB. Ao contrário de outros sistemas de banco de dados, o MariaDB reconstrói a tabela inteira ao adicionar ou modificar índices secundários. Esse processo cria outra tabela com alterações no índice, copia todos os dados e descarta a tabela original.
+ Carregue os dados na ordem da chave primária. Quanto a tabelas do InnoDB, isso pode reduzir os tempos de carregamento em 75% a 80% e diminuir o tamanho do arquivo de dados em 50%.
+ Desabilite as restrições de chave estrangeira definindo `foreign_key_checks` como `0`. Isso com frequência é necessário para arquivos simples carregados com `LOAD DATA LOCAL INFILE`. Com relação a qualquer carregamento, desabilitar as verificações de chave estrangeira acelera o carregamento de dados. Após a conclusão do carregamento, habilite novamente as restrições configurando `foreign_key_checks` como `1` e verifique os dados.
+ Carregue os dados em paralelo, a menos que esteja se aproximando de um limite de recursos. Para habilitar o carregamento simultâneo em vários segmentos da tabela, use tabelas particionadas quando apropriado.
+ Para reduzir os custos indiretos de execução do SQL, combine várias instruções `INSERT` em operações `INSERT` únicas de vários valores. `mariadb-dump` implementa essa otimização automaticamente.
+ Reduza as operações de E/S de log do InnoDB configurando `innodb_flush_log_at_trx_commit` como `0`. Após a conclusão do carregamento, restaure `innodb_flush_log_at_trx_commit` para `1`.
**Atenção**
Ao definir `innodb_flush_log_at_trx_commit` como `0`, o InnoDB descarrega os respectivos logs a cada segundo em vez de a cada confirmação. Essa configuração aumenta a performance, mas pode gerar risco de perda de transações durante falhas no sistema.
+ Se você estiver carregando dados em uma instância de banco de dados que não tem réplicas de leitura, defina `sync_binlog` como `0`. Após a conclusão do carregamento, restaure `sync_binlog parameter` para `1`.
+ Carregue os dados antes de converter a instância de banco de dados em uma implantação multi-AZ. Se a instância de banco de dados já utiliza uma implantação multi-AZ, não recomendamos mudar para uma implantação single-AZ para carregamento de dados. Se fizer isso, obterá apenas pequenas melhorias.
# Importar dados de um banco de dados externo do MariaDB para uma instância de banco de dados do Amazon RDS para MariaDB
É possível importar dados de um banco de dados MariaDB existente para uma instância de banco de dados do RDS para MariaDB. Para isso, copie o banco de dados com [mysqldump](https://dev.mysql.com/doc/refman/8.0/en/mysqldump.html) ou [mariadb-dump](https://mariadb.com/kb/en/mariadb-dump/) e conecte-o diretamente à instância de banco de dados do RDS para MariaDB. O utilitário de linha de comando `mysqldump` ou `mariadb-dump` é comumente usado para fazer backups e transferir dados de um servidor do MariaDB para outro. Ele está incluído no software-cliente do MariaDB.
A partir do MariaDB 11.0.1, você deve usar `mariadb-dump` em vez de `mysqldump`.
Um comando `mysqldump` típico para mover dados de um banco de dados externo para uma instância de banco de dados do Amazon RDS é semelhante ao exemplo a seguir. Substitua os valores por suas próprias informações. Para o MariaDB 11.0.1 e versões posteriores, substitua `mysqldump` por `mariadb-dump`.
```
mysqldump -u local_user \
--databases database_name \
--single-transaction \
--compress \
--order-by-primary \
--routines=0 \
--triggers=0 \
--events=0 \
-plocal_password | mariadb -u RDS_user \
--port=port_number \
--host=host_name \
-pRDS_password
```
**Importante**
Não deixe um espaço entre a opção `-p` e a senha inserida.
Faz parte das práticas recomendadas de segurança especificar credenciais diferentes dos prompts mostrados neste exemplo.
Analise as seguintes recomendações e considerações:
+ Exclua os seguintes esquemas do arquivo de despejo:
+ `sys`
+ `performance_schema`
+ `information_schema`
O utilitário `mysqldump` e `mariadb-dump` exclui esses esquemas por padrão.
+ Para migrar usuários e privilégios, considere o uso de uma ferramenta que gera a linguagem de controle de dados (DCL) para recriá-los, como o utilitário [pt-show-grants](https://www.percona.com/doc/percona-toolkit/LATEST/pt-show-grants.html).
+ Para realizar a importação, verifique se o usuário que está fazendo isso tem acesso à instância de banco de dados. Para obter mais informações, consulte [Controlar acesso com grupos de segurança](Overview.RDSSecurityGroups.md).
Os parâmetros utilizados são os seguintes:
+ `-u local_user` – use para especificar um nome do usuário. Ao usar esse parâmetro pela primeira vez, especifique o nome de uma conta de usuário no banco de dados local MariaDB que você identifica com o parâmetro `--databases`.
+ `--databases database_name`: use para especificar o nome do banco de dados na instância do MariaDB local que você deseja importar para o Amazon RDS.
+ `--single-transaction` – use para garantir que todos os dados carregados do banco de dados local sejam consistentes com um único ponto no tempo. Se houver outros processos alterando os dados enquanto eles são lidos por `mysqldump` ou `mariadb-dump`, usar esse parâmetro ajudará a manter a integridade dos dados.
+ `--compress` – use para reduzir o consumo de largura de banda da rede, compactando os dados do banco de dados local antes de os enviar para o Amazon RDS.
+ `--order-by-primary` – use para reduzir o tempo de carregamento, ordenando os dados de cada tabela de acordo com a chave primária.
+ `--routines`: use se houver determinadas rotinas, como funções ou procedimentos armazenados, no banco de dados que você está copiando. Defina o parâmetro como `0`, o que exclui as rotinas durante o processo de importação. Depois, recrie manualmente as rotinas no banco de dados do Amazon RDS.
+ `--triggers`: use se houver gatilhos no banco de dados que você está copiando. Defina o parâmetro como `0`, o que exclui os gatilhos durante o processo de importação. Depois, recrie manualmente os gatilhos no banco de dados do Amazon RDS.
+ `--events`: use se houver eventos no banco de dados que você está copiando. Defina o parâmetro como `0`, o que exclui os eventos durante o processo de importação. Em seguida, recrie manualmente os eventos no banco de dados do Amazon RDS.
+ `-plocal_password`: use para especificar uma senha. Ao usar esse parâmetro pela primeira vez, especifique a senha da conta de usuário que você identifica com o primeiro parâmetro `-u`.
+ `-u RDS_user` – use para especificar um nome do usuário. Ao usar esse parâmetro pela segunda vez, especifique o nome de uma conta de usuário no banco de dados padrão para a instância de banco de dados do MariaDB que você identifica com o parâmetro `--host`.
+ `--port port_number`: use para especificar a porta da sua instância de banco de dados do MariaDB. Por padrão, essa porta é 3306, a menos que você tenha alterado o valor ao criar a instância de banco de dados.
+ `--host host_name` – use para especificar o nome do Sistema de Nome de Domínio (DNS) do endpoint da instância de banco de dados Amazon RDS, por exemplo, `myinstance.123456789012.us-east-1.rds.amazonaws.com`. Você pode encontrar o valor do endpoint nos detalhes da instância do banco de dados no console do Amazon RDS.
+ `-pRDS_password` – use para especificar uma senha. Na segunda utilização desse parâmetro, você especifica a senha da conta de usuário identificada pelo segundo parâmetro `-u`.
Certifique-se de criar procedimentos armazenados, acionadores, funções ou eventos manualmente no seu banco de dados Amazon RDS. Se algum desses objetos estiver no banco de dados que você está copiando, exclua-os quando executar `mysqldump` ou `mariadb-dump`. Para fazer isso, inclua os seguintes parâmetros com o comando `mysqldump` ou `mariadb-dump`:
+ `--routines=0`
+ `--triggers=0`
+ `--events=0`
**Exemplo**
O exemplo a seguir copia o banco de dados de exemplo `world` no host local para uma instância de banco de dados do RDS para MariaDB. Substitua os valores por suas próprias informações.
Para Linux, macOS ou Unix:
```
sudo mariadb-dump -u local_user \
--databases world \
--single-transaction \
--compress \
--order-by-primary \
--routines=0 \
--triggers=0 \
--events=0 \
-plocal_password | mariadb -u rds_user \
--port=3306 \
--host=my_instance.123456789012.us-east-1.rds.amazonaws.com \
-pRDS_password
```
Para Windows:
Execute o comando a seguir em um prompt de comando que foi aberto clicando com o botão direito do mouse em **Prompt de comando** no menu de programas do Windows e escolhendo **Executar como administrador**. Substitua os valores por suas próprias informações.
```
mariadb-dump -u local_user ^
--databases world ^
--single-transaction ^
--compress ^
--order-by-primary ^
--routines=0 ^
--triggers=0 ^
--events=0 ^
-plocal_password | mariadb -u RDS_user ^
--port=3306 ^
--host=my_instance.123456789012.us-east-1.rds.amazonaws.com ^
-pRDS_password
```
**nota**
Faz parte das práticas recomendadas de segurança especificar credenciais diferentes dos prompts mostrados no exemplo.
# Importar dados para uma instância de banco de dados do Amazon RDS para MariaDB com tempo de inatividade reduzido
Em alguns casos, você pode precisar importar dados de um banco de dados MariaDB externo que aceite uma aplicação dinâmica para uma instância de banco de dados RDs para MariaDB. Use o procedimento a seguir para minimizar o impacto sobre a disponibilidade das aplicações. Este procedimento também pode ser útil se você está trabalhando com um banco de dados muito grande. Usando esse procedimento, você pode reduzir o custo da importação ao diminuir a quantidade de dados transmitidos pela rede para a AWS.
Neste procedimento, você transfere uma cópia dos dados do banco de dados para uma instância do Amazon EC2 e importa os dados em um novo banco de dados do Amazon RDS. Depois, use a replicação para atualizar o banco de dados do Amazon RDS em relação à instância externa dinâmica, antes de redirecionar sua aplicação ao banco de dados do Amazon RDS. Se a instância externa for do MariaDB 10.0.24 ou posterior e a instância de destino for do RDS para MariaDB, configure a replicação do MariaDB com base em identificadores de transação global (GTIDs). Caso contrário, configure a replicação com base nas coordenadas do log binário. Recomendamos a replicação baseada em GTID caso o banco de dados externo comporte esse tipo de replicação, já que é um método mais confiável. Para obter mais informações, consulte [Global Transaction ID](http://mariadb.com/kb/en/mariadb/global-transaction-id/) na documentação do MariaDB.
O diagrama a seguir mostra como importar um banco de dados MariaDB externo para um banco de dados MariaDB no Amazon RDS.
![\[Fluxo de trabalho que mostra como importar um banco de dados MariaDB externo para um banco de dados MariaDB no Amazon RDS.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_1.png)
## Tarefa 1: criar uma cópia do banco de dados existente
A primeira etapa do processo de migração de um grande volume de dados para um banco de dados RDS para MariaDB com o mínimo de tempo de inatividade é criar uma cópia dos dados de origem.
O diagrama a seguir mostra como criar um backup do banco de dados MariaDB.
![\[Fluxo de trabalho que mostra como criar um backup do banco de dados MariaDB.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_2.png)
Você pode usar o utilitário `mysqldump` ou `mariadb-dump` para criar um backup de banco de dados no formato SQL ou de texto delimitado. No MariaDB 10.5, o cliente é chamado de [mariadb-dump](https://mariadb.com/kb/en/mariadb-dump/). A partir do MariaDB 11.0.1, você deve usar `mariadb-dump` em vez de `mysqldump`. Recomendamos que você faça uma execução de teste com cada formato em um ambiente que não seja de produção para ver qual método minimiza o tempo de execução de `mysqldump` ou `mariadb-dump`.
Recomendamos também que você pondere a performance de `mysqldump` ou `mariadb-dump` em relação ao benefício oferecido usando o formato de texto delimitado para o carregamento. Um backup usando o formato de texto delimitado cria um arquivo de texto separado por tabulação para cada tabela que está sendo despejada. Você pode carregar esses arquivos em paralelo usando o comando `LOAD DATA LOCAL INFILE` para reduzir a quantidade de tempo necessária para importar seu banco de dados. Para acessar mais informações, consulte [Etapa 5: Carregar os dados](mariadb-importing-data-any-source.md#mariadb-importing-data-any-source-load-data) no procedimento Importar dados de qualquer origem.
Antes de iniciar a operação de backup, defina as opções de replicação no banco de dados MariaDB que está copiando para o Amazon RDS. As opções de replicação incluem ativar o registro em log binário e definir um ID de servidor exclusivo. Configurar essas opções faz com que seu servidor comece a registrar em log transações de banco de dados e o prepara para ser um uma instância de replicação de origem mais adiante nesse processo.
Analise as seguintes recomendações e considerações:
+ Use a opção `--single-transaction` com `mysqldump` ou `mariadb-dump` porque ela despeja um estado consistente do banco de dados. Para garantir um arquivo de despejo válido, não execute instruções DDL enquanto `mysqldump` ou `mariadb-dump` estiver em execução. É possível programar uma janela de manutenção para essas operações.
+ Exclua os seguintes esquemas do arquivo de despejo:
+ `sys`
+ `performance_schema`
+ `information_schema`
Os utilitários `mysqldump` e `mariadb-dump` excluem esses esquemas por padrão.
+ Para migrar usuários e privilégios, considere o uso de uma ferramenta que gera a linguagem de controle de dados (DCL) para recriá-los, como o utilitário [pt-show-grants](https://www.percona.com/doc/percona-toolkit/LATEST/pt-show-grants.html).
### Como definir opções de replicação
1. Edite o arquivo `my.cnf`. Esse arquivo geralmente está localizado em `/etc`.
```
sudo vi /etc/my.cnf
```
Adicione as opções `log_bin` e `server_id` à seção `[mysqld]`. A opção `log_bin` fornece um identificador de nome de arquivo para arquivos de log binário. A opção `server_id` fornece um identificador exclusivo para o servidor em relações entre origem e réplica.
O seguinte exemplo mostra a seção `[mariadb]` atualizada de um arquivo `my.cnf`:
```
[mariadb]
log-bin
server-id=1
log-basename=master1
binlog-format=mixed
```
Para acessar mais informações, consulte [Setting the Replication Source Configuration](https://mariadb.com/docs/server/ha-and-performance/standard-replication/setting-up-replication) na documentação do MariaDB.
1. Para a replicação com um cluster de banco de dados multi-AZ, habilite `gtid_strict_mode`. Para acessar mais informações, consulte [gtid\$1strict\$1mode](https://mariadb.com/docs/server/ha-and-performance/standard-replication/gtid#gtid_strict_mode) na documentação do MariaDB.
A ativação de `gtid_strict_mode` não é necessária para a replicação com uma instância de banco de dados.
1. Reinicie o serviço `mariadb`.
```
sudo service mariadb restart
```
### Como criar uma cópia de backup do banco de dados existente
1. Crie um backup dos dados por meio do utilitário `mysqldump` ou `mariadb-dump`, especificando o formato SQL ou de texto delimitado.
Para melhorar a performance e garantir a integridade dos dados, use as opções `--order-by-primary` e `--single-transaction` para `mysqldump` e `mariadb-dump`.
Para evitar a inclusão do banco de dados do sistema MySQL no backup, não use a opção `--all-databases` com `mysqldump` ou `mariadb-dump`. Para ter mais informações, consulte [Creating a Data Snapshot Using mysqldump](https://dev.mysql.com/doc/mysql-replication-excerpt/8.0/en/replication-howto-mysqldump.html) na documentação do MySQL.
Use `chmod`, se necessário, para garantir que o diretório no qual o arquivo de backup está sendo criado seja gravável.
**Importante**
No Windows, execute a janela de comando como um administrador.
+ Para produzir a saída SQL, use o comando a seguir. Para o MariaDB 10.11 e versões posteriores, substitua `mariadb-dump` por `mysqldump`.
Para Linux, macOS ou Unix:
```
sudo mariadb-dump \
--databases database_name \
--master-data=2 \
--single-transaction \
--order-by-primary \
-r backup.sql \
-u local_user \
-ppassword
```
**nota**
Faz parte das práticas recomendadas de segurança especificar credenciais diferentes dos prompts mostrados no exemplo.
Para Windows:
```
mariadb-dump ^
--databases database_name ^
--master-data=2 ^
--single-transaction ^
--order-by-primary ^
-r backup.sql ^
-u local_user ^
-ppassword
```
**nota**
Faz parte das práticas recomendadas de segurança especificar credenciais diferentes dos prompts mostrados no exemplo.
+ Para produzir uma saída de texto delimitado, use o comando a seguir. Para o MariaDB 11.01 e versões posteriores, substitua `mysqldump` por `mariadb-dump`.
Para Linux, macOS ou Unix:
```
sudo mysqldump \
--tab=target_directory \
--fields-terminated-by ',' \
--fields-enclosed-by '"' \
--lines-terminated-by 0x0d0a \
database_name \
--master-data=2 \
--single-transaction \
--order-by-primary \
-ppassword
```
Para Windows:
```
mysqldump ^
--tab=target_directory ^
--fields-terminated-by "," ^
--fields-enclosed-by """ ^
--lines-terminated-by 0x0d0a ^
database_name ^
--master-data=2 ^
--single-transaction ^
--order-by-primary ^
-ppassword
```
**nota**
Faz parte das práticas recomendadas de segurança especificar credenciais diferentes dos prompts mostrados no exemplo.
Certifique-se de criar procedimentos armazenados, acionadores, funções ou eventos manualmente no seu banco de dados Amazon RDS. Se algum desses objetos estiver no banco de dados que você está copiando, exclua-os quando executar `mysqldump` ou `mariadb-dump`. Para fazer isso, inclua estes argumentos com o comando `mysqldump` ou `mariadb-dump`:
`--routines=0`
`--triggers=0`
`--events=0`
Quando você executa `mysqldump` e especifica o formato de texto delimitado, um comentário `CHANGE MASTER TO` é exibido. Esse comentário contém o nome e a posição do arquivo de log mestre. Se a instância externa for o MariaDB 10.0.2e ou posterior, observe os valores para `MASTER_LOG_FILE` e `MASTER_LOG_POS`. Esses valores são necessários ao configurar a replicação.
A seguinte saída é exibida para versões do MariaDB.
```
-- Position to start replication or point-in-time recovery from
--
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin-changelog.000031', MASTER_LOG_POS=107;
```
1. Se a versão da instância externa que você está usando for MariaDB 10.0.24 ou posterior, use a replicação baseada em GTID. Execute `SHOW MASTER STATUS` na instância externa do MariaDB para obter o nome e a posição do arquivo de log binário. Em seguida, converta-o em um GTID executando `BINLOG_GTID_POS` na instância externa do MariaDB.
```
SELECT BINLOG_GTID_POS('binary_log_file_name', binary_log_file_position);
```
Anote o GTID retornado. Você precisará dele para configurar a replicação.
1. Compacte os dados copiados para reduzir a quantidade de recursos de rede necessários para copiar seus dados para o banco de dados do Amazon RDS. Anote o tamanho do arquivo de backup. Você precisará dessas informações ao determinar o tamanho de uma instância do Amazon EC2 a ser criada. Quando terminar, compacte o arquivo de backup usando o GZIP ou seu utilitário de compactação preferido.
+ Para compactar a saída SQL, use o seguinte comando:
```
gzip backup.sql
```
+ Para compactar a saída de texto delimitado, use o seguinte comando:
```
tar -zcvf backup.tar.gz target_directory
```
## Tarefa 2: criar uma instância do Amazon EC2 e copiar o banco de dados compactado
Copiar seu arquivo de backup de banco de dados compactado para uma instância do Amazon EC2 requer menos recursos de rede do que fazer uma cópia direta de dados não compactados entre instâncias de bancos de dados. Depois que seus dados estiverem no Amazon EC2, você poderá copiá-los de lá diretamente para o banco de dados MariaDB. Para reduzir o custo dos recursos de rede, a instância do Amazon EC2 deve estar na mesma Região da AWS que a instância de banco de dados do Amazon RDS. Ter a instância do Amazon EC2 na mesma Região da AWS que o banco de dados do Amazon RDS também reduz a latência da rede durante a importação.
O diagrama a seguir mostra como copiar o backup do banco de dados para uma instância do Amazon EC2.
![\[Fluxo de trabalho que mostra como copiar o backup do banco de dados para uma instância do EC2.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_3.png)
### Como criar uma instância do Amazon EC2 e copiar seus dados
1. Na Região da AWS em que você planeja criar o banco de dados do Amazon RDS, crie uma nuvem privada virtual (VPC), um grupo de segurança de VPC e uma sub-rede de VPC. Certifique-se de que as regras de entrada para o grupo de segurança da VPC permitam os endereços IP necessários para a aplicação se conectar ao AWS. Você pode especificar uma variedade de endereços IP (por exemplo, `203.0.113.0/24`) ou outro grupo de segurança de VPC. É possível usar o [console da Amazon VPC](https://console.aws.amazon.com/vpc) para criar e gerenciar VPCs, sub-redes e grupos de segurança. Para ter mais informações, consulte [Conceitos básicos da Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html#getting-started) no *Manual do usuário da Amazon Virtual Private Cloud*.
1. Abra o [console do Amazon EC2](https://console.aws.amazon.com/ec2) e escolha a Região da AWS para conter tanto a instância do Amazon EC2 como o banco de dados do Amazon RDS. Inicie uma instância do Amazon EC2 usando a VPC, a sub-rede e o grupo de segurança que você criou na Etapa 1. Certifique-se de selecionar um tipo de instância com armazenamento suficiente para o arquivo de backup de banco de dados quando ele não estiver compactado. Para ter detalhes sobre instâncias do Amazon EC2, consulte [Comece a usar o Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html) no *Guia do usuário do Amazon Elastic Compute Cloud*.
1. Para se conectar ao banco de dados do Amazon RDS pela sua instância do Amazon EC2, edite seu grupo de segurança da VPC. Adicione uma regra de entrada especificando o endereço IP privado da sua instância do EC2. Você pode encontrar o endereço IP privado na guia **Details (Detalhes)** do painel **Instance (Instância)** na janela do console do EC2. Para editar o grupo de segurança de VPC e adicionar uma regra de entrada, escolha **Security Groups (Grupos de segurança)** no painel de navegação do console do EC2, escolha o grupo de segurança e, em seguida, adicione uma regra de entrada para MySQL ouAurora especificando o endereço IP privado da sua instância do EC2. Para saber como adicionar uma regra de entrada a um grupo de segurança de VPC, consulte [Regras de grupos de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/security-group-rules.html) no *Manual do usuário da Amazon Virtual Private Cloud*.
1. Copie o arquivo de backup de banco de dados compactado do seu sistema local para a sua instância do Amazon EC2. Use `chmod`, se necessário, para garantir que você tenha permissão de gravação para o diretório de destino da instância do Amazon EC2. Você pode usar `scp` ou um cliente Secure Shell (SSH) para copiar o arquivo. O seguinte comando é um exemplo de comando `scp`:
```
scp -r -i key pair.pem backup.sql.gz ec2-user@EC2 DNS:/target_directory/backup.sql.gz
```
**Importante**
Ao copiar dados sensíveis, use um protocolo de transferência de rede segura.
1. Conecte-se à sua instância do Amazon EC2 e instale as atualizações e as ferramentas do cliente MariaDB mais recentes usando os seguintes comandos:
```
sudo yum update -y
sudo yum install mariadb1011-client-utils -y
```
Para acessar mais informações, consulte [Conectar-se à instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-connect-to-instance-linux) para instâncias do Linux no *Guia do usuário do Amazon Elastic Compute Cloud* e [MariaDB Connectors](https://mariadb.com/docs/connectors) na documentação do MariaDB.
1. Enquanto estiver conectado à sua instância do Amazon EC2, descompacte o arquivo de backup do banco de dados. Os comandos a seguir são exemplos.
+ Para descompactar a saída SQL, use o seguinte comando:
```
gzip backup.sql.gz -d
```
+ Para descomprimir a saída de texto delimitada, use o seguinte comando:
```
tar xzvf backup.tar.gz
```
## Tarefa 3: criar um banco de dados MariaDB e importar os dados da instância do Amazon EC2
Ao criar uma instância de banco de dados do RDS para MariaDB na mesma Região da AWS que a sua instância do Amazon EC2, você pode importar o arquivo de backup do banco de dados do Amazon EC2 mais rápido do que ao importá-lo pela Internet.
O diagrama a seguir mostra como importar o backup de uma instância do Amazon EC2 para um banco de dados MariaDB.
![\[Fluxo de trabalho que mostra como importar o backup da instância do EC2 para o banco de dados MariaDB.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_4.png)
### Como criar um banco de dados MariaDB e importar seus dados
1. Determine qual classe de instância de banco de dados e que quantidade de espaço de armazenamento são necessários para atender à workload esperada para esse banco de dados do Amazon RDS. Como parte desse processo, decida sobre o espaço suficiente e a capacidade de processamento para os seus procedimentos de carregamento de dados. Além disso, decida o que é necessário para lidar com a workload de produção. Você pode estimar isso com base no tamanho e nos recursos do banco de dados MariaDB de origem. Para obter mais informações, consulte [Classes de instâncias de banco de dados do ](Concepts.DBInstanceClass.md).
1. Crie uma instância de banco de dados no Região da AWS que contenha a instância do Amazon EC2. Siga as instruções em [Criar uma instância de banco de dados do Amazon RDS](USER_CreateDBInstance.md) use as seguintes diretrizes:
+ Especifique uma versão do mecanismo de banco de dados que seja compatível com a sua instância de banco de dados de origem.
+ Especifique a mesma nuvem privada virtual (VPC) e o grupo de segurança da VPC para sua instância do Amazon EC2. Essa abordagem garante que sua instância do Amazon EC2 e sua instância do Amazon RDS sejam visíveis uma para a outra na rede. Verifique se sua instância de banco de dados pode ser acessada publicamente. Para configurar a replicação com o banco de dados de origem, conforme descrito em uma seção mais adiante, a instância de banco de dados deve ser acessível ao público.
+ Não configure várias zonas de disponibilidade, retenção de backup nem réplicas de leitura até depois de ter importado o backup do banco de dados. Quando a importação estiver concluída, você poderá configurar o recurso multi-AZ e a retenção de backup para a instância de produção.
1. Reveja as opções de configuração padrão para o banco de dados do Amazon RDS. Se o grupo de parâmetros padrão para o banco de dados não tiver as opções de configuração desejadas, encontre outro que as inclua ou crie um grupo de parâmetros. Para ter mais informações sobre como criar um grupo de parâmetros, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
1. Conecte-se ao novo banco de dados do Amazon RDS como usuário principal. Crie os usuários necessários para dar suporte aos administradores, aplicações e serviços que precisam acessar a instância de banco de dados. O nome do host para o banco de dados do Amazon RDS é o valor do **endpoint** dessa instância, de banco de dados sem o número da porta; por exemplo, `mysampledb.123456789012.us-west-2.rds.amazonaws.com`. Você pode encontrar o valor do endpoint nos detalhes do banco de dados no console do Amazon RDS.
1. Conecte-se à sua instância Amazon EC2. Para ter mais informações, consulte [Conectar-se à instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html#ec2-connect-to-instance-linux) no *Guia do usuário do Amazon Elastic Compute Cloud para Linux*.
1. Conecte-se ao seu banco de dados do Amazon RDS como um host remoto pela sua instância do Amazon EC2 usando o comando `mysql`. O seguinte comando é um exemplo:
```
mysql -h host_name -P 3306 -u db_master_user -p
```
O *host\$1name* é o endpoint do banco de dados do Amazon RDS.
1. No prompt `mysql`, execute o comando `source` e passe a ele o nome do arquivo de despejo do banco de dados. Esse comando carrega os dados na instância de banco de dados do Amazon RDS.
+ Para o formato SQL, use o seguinte comando:
```
MariaDB [(none)]> source backup.sql;
```
+ Para o formato de texto delimitado, primeiro crie o banco de dados, se ele não for o banco de dados padrão que você criou ao configurar o banco de dados do Amazon RDS.
```
MariaDB [(none)]> create database database_name;
MariaDB [(none)]> use database_name;
```
Em seguida, crie as tabelas.
```
MariaDB [(none)]> source table1.sql
MariaDB [(none)]> source table2.sql
etc...
```
Em seguida, importe os dados.
```
MariaDB [(none)]> LOAD DATA LOCAL INFILE 'table1.txt' INTO TABLE table1 FIELDS TERMINATED BY ',' ENCLOSED BY '"' LINES TERMINATED BY '0x0d0a';
MariaDB [(none)]> LOAD DATA LOCAL INFILE 'table2.txt' INTO TABLE table2 FIELDS TERMINATED BY ',' ENCLOSED BY '"' LINES TERMINATED BY '0x0d0a';
etc...
```
Para melhorar a performance, você pode realizar essas operações em paralelo de várias conexões, para que todas as tabelas sejam criadas e carregadas ao mesmo tempo.
**nota**
Se você usou qualquer opção de formatação de dados com `mysqldump` ou `mariadb-dump` quando despejou inicialmente a tabela, use as mesmas opções com `LOAD DATA LOCAL INFILE` para assegurar uma interpretação adequada do conteúdo do arquivo de dados.
1. Execute uma consulta `SELECT` simples em uma ou duas das tabelas no banco de dados importado para verificar se a importação foi bem-sucedida.
Se você não precisa mais da instância do Amazon EC2 usada neste procedimento, encerre-a para reduzir o uso de recursos de uso da AWS. Para encerrar uma instância do EC2, consulte [Como encerrar uma instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#terminating-instances-console) no *Guia do usuário do Amazon Elastic Compute Cloud*.
## Tarefa 4: replicar dados do banco de dados externo para o novo banco de dados do Amazon RDS
Seu banco de dados de origem provavelmente foi atualizado durante o tempo decorrido entre a cópia e a transferência dos dados para o banco de dados MariaDB. Você pode usar a replicação para atualizar o banco de dados copiado com o banco de dados de origem.
![\[Fluxo de trabalho que mostra como replicar dados do banco de dados MariaDB externo para o banco de dados no Amazon RDS.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_5.png)
As permissões necessárias para iniciar a replicação em um banco de dados do Amazon RDS são restritas e não estão disponíveis ao seu usuário principal do Amazon RDS. Por esse motivo, use o procedimento armazenado apropriado do Amazon RDS:
+ [mysql.rds\$1set\$1external\$1master](mysql-stored-proc-replicating.md#mysql_rds_set_external_master)
+ [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md) para configurar a replicação e [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) para iniciar a replicação
### Como iniciar a replicação
Na Tarefa 1, [ao definir as opções de replicação](#mariadb-importing-data-reduced-downtime-set-replication-options), você ativou o registro em log binário e definiu um ID de servidor exclusivo para o banco de dados de origem. Agora, é possível configurar seu banco de dados Amazon RDS como uma réplica com seu banco de dados dinâmico como a instância de replicação de origem.
1. No console do Amazon RDS, adicione o endereço IP do servidor que hospeda o banco de dados de origem ao grupo de segurança da VPC para o banco de dados do Amazon RDS. Para ter mais informações sobre grupos de segurança da VPC, consulte [Configurar regras de grupo de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-security-group-rules.html) no *Manual do usuário da Amazon Virtual Private Cloud*.
Você também pode precisar configurar a rede local para permitir conexões com o endereço IP do banco de dados do Amazon RDS, para que ele possa se comunicar com a instância de origem. Para localizar o endereço IP do banco de dados do Amazon RDS, use o comando `host`:
```
host host_name
```
O *host\$1name* é o nome DNS do endpoint do banco de dados do Amazon RDS; por exemplo, `myinstance.123456789012.us-east-1.rds.amazonaws.com`. Você pode encontrar o valor do endpoint nos detalhes da instância do banco de dados no console do Amazon RDS.
1. Usando o cliente de sua preferência, conecte-se à instância de origem e crie um usuário a ser usado para a replicação. Esta conta é usada unicamente para replicação e deve estar restrita ao seu domínio para melhorar a segurança. O seguinte comando é um exemplo:
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**nota**
Especifique credenciais diferentes dos prompts mostrados aqui como prática recomendada de segurança.
1. Para a instância de origem, conceda os privilégios `REPLICATION CLIENT` e `REPLICATION SLAVE` para seu usuário de replicação. Por exemplo, para conceder os privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` em todos os bancos de dados para o usuário '`repl_user`' de seu domínio, emita o seguinte comando:
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
1. Se você tiver usado o formato SQL para criar o arquivo de backup e a versão da instância externa não for MariaDB 10.0.24 ou posterior, veja o conteúdo desse arquivo executando o seguinte comando:
```
cat backup.sql
```
O arquivo inclui um comentário `CHANGE MASTER TO` que contém o nome e a posição do arquivo de log mestre. Esse comentário está incluído no arquivo de backup quando você usa a opção `--master-data` com `mysqldump`. Observe os valores para `MASTER_LOG_FILE` e `MASTER_LOG_POS`.
```
--
-- Position to start replication or point-in-time recovery from
--
-- CHANGE MASTER TO MASTER_LOG_FILE='mysql-bin-changelog.000031', MASTER_LOG_POS=107;
```
Se você usou o formato de texto delimitado para criar o arquivo de backup e a versão da instância externa não for MariaDB 10.0.24 ou posterior, você já deve ter coordenadas de logs binários da Etapa 1 na Tarefa 1 [ao criar uma cópia de backup do banco de dados existente](#mariadb-importing-data-reduced-downtime-create-backup).
Se a versão da instância externa for MariaDB 10.0.24 ou posterior, você já deve ter o GTID com base no qual iniciar a replicação na Etapa 2, na Tarefa 1 [ao criar uma cópia de backup do banco de dados existente](#mariadb-importing-data-reduced-downtime-create-backup).
1. Torne o banco de dados do Amazon RDS a réplica. Se a versão da instância externa não for o MariaDB 10.0.24 ou posterior, conecte-se ao banco de dados Amazon RDS como o usuário principal e identifique o banco de dados de origem como a instância de replicação de origem usando o procedimento armazenado [mysql.rds\$1set\$1external\$1master](mysql-stored-proc-replicating.md#mysql_rds_set_external_master).
Se você tiver um arquivo de backup no formato SQL, use o nome do arquivo de log mestre e a posição do log mestre que você determinou na Etapa 4. Se você usou o formato de texto delimitado, use o nome e a posição que você determinou ao criar os arquivos de backup. O seguinte comando é um exemplo:
```
CALL mysql.rds_set_external_master ('myserver.mydomain.com', 3306,
'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**nota**
Especifique credenciais diferentes dos prompts mostrados aqui como prática recomendada de segurança.
Se a versão da instância externa for o MariaDB 10.0.24 ou posterior, conecte-se ao banco de dados Amazon RDS como o usuário principal e identifique o banco de dados de origem como a instância de replicação de origem usando o procedimento armazenado [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md). Use o GTID que você determinou na Etapa 2 da Tarefa 1 [quando criou uma cópia de backup do banco de dados existente](#mariadb-importing-data-reduced-downtime-create-backup). O seguinte comando é um exemplo:
```
CALL mysql.rds_set_external_master_gtid ('source_server_ip_address', 3306, 'ReplicationUser', 'password', 'GTID', 1);
```
O `source_server_ip_address` é o endereço IP da instância de replicação de origem. No momento, não é possível usar um endereço DNS privado do EC2.
**nota**
Especifique credenciais diferentes dos prompts mostrados aqui como prática recomendada de segurança.
1. No banco de dados Amazon RDS, para iniciar a replicação, execute o seguinte comando que usa o procedimento armazenado [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication):
```
CALL mysql.rds_start_replication;
```
1. No banco de dados Amazon RDS, para determinar quando a réplica está atualizada com a instância de replicação de origem, execute o comando [SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html). Os resultados do comando `SHOW REPLICA STATUS` incluem o campo `Seconds_Behind_Master`. Quando o campo `Seconds_Behind_Master` retorna 0, a réplica é atualizada com a instância de replicação de origem.
Para uma instância de banco de dados do MariaDB 10.5, 10.6, 10.11, 11.4 ou 11.8, use o procedimento armazenado [mysql.rds\$1replica\$1status](mysql_rds_replica_status.md) em vez do comando do MySQL.
1. Depois que o banco de dados do Amazon RDS estiver atualizado, ative backups automatizados para poder restaurar esse banco de dados, se necessário. Você pode ativar ou modificar backups automatizados para um banco de dados do Amazon RDS usando o [console do Amazon RDS](https://console.aws.amazon.com/rds/). Para obter mais informações, consulte [Introdução aos backups](USER_WorkingWithAutomatedBackups.md).
## Tarefa 5: redirecionar a aplicação ativa para a instância do Amazon RDS
Depois que o banco de dados MariaDB estiver atualizado com a instância de replicação de origem, será possível atualizar sua aplicação dinâmica para usar a instância do Amazon RDS.
![\[Fluxo de trabalho que mostra como interromper a replicação e direcionar a aplicação ativa para o banco de dados no Amazon RDS.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/MigrateMariaDBToRDS_6.png)
### Como redirecionar a aplicação dinâmica para o banco de dados MariaDB e interromper a replicação
1. Para adicionar o grupo de segurança de VPC para o banco de dados do Amazon RDS, adicione o endereço IP do servidor que hospeda a aplicação. Para ter mais informações sobre como modificar um grupo de segurança de VPC, consulte [Configurar regras de grupo de segurança](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-security-group-rules.html) no *Manual do usuário da Amazon Virtual Private Cloud*.
1. Verifique se o campo `Seconds_Behind_Master` nos resultados do comando [SHOW REPLICA STATUS](https://dev.mysql.com/doc/refman/8.0/en/show-replica-status.html) é 0, o que indica que a réplica está atualizada com a instância de replicação de origem.
```
SHOW REPLICA STATUS;
```
Para uma instância de banco de dados do MariaDB 10.5, 10.6, 10.11, 11.4 ou 11.8, use o procedimento armazenado [mysql.rds\$1replica\$1status](mysql_rds_replica_status.md) em vez do comando do MySQL.
1. Feche todas as conexões com a origem quando suas transações terminarem.
1. Atualize sua aplicação para usar o banco de dados do Amazon RDS. Normalmente, essa atualização envolve a alteração das configurações de conexão para identificar o nome do host e a porta do banco de dados do Amazon RDS, a conta de usuário e a senha para conexão e o banco de dados para uso.
1. Conecte-se à instância de banco de dados.
1. Interrompa a replicação da instância do Amazon RDS usando o seguinte comando que usa o procedimento armazenado [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication):
```
CALL mysql.rds_stop_replication;
```
1. Redefina a configuração de replicação de maneira que essa instância não seja mais identificada como uma réplica, executando o seguinte comando que usa o procedimento armazenado [mysql.rds\$1reset\$1external\$1master](mysql-stored-proc-replicating.md#mysql_rds_reset_external_master) em seu banco de dados Amazon RDS.
```
CALL mysql.rds_reset_external_master;
```
1. Ative recursos adicionais do Amazon RDS, como o suporte a multi-AZ e réplicas de leitura. Para obter mais informações, consulte [Configurar e gerenciar uma implantação multi-AZ para o Amazon RDS](Concepts.MultiAZ.md) e [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
# Importar dados de qualquer fonte para uma instância de banco de dados do Amazon RDS para MariaDB
Com o Amazon RDS, você pode migrar dados existentes do MariaDB de qualquer origem para uma instância de banco de dados do RDS para MariaDB. Você pode transferir dados de bancos de dados on-premises, outros provedores de nuvem ou instâncias de banco de dados do RDS para MariaDB existentes para sua instância de banco de dados do RDS para MariaDB de destino. Com essa funcionalidade, você pode consolidar bancos de dados, implementar soluções de recuperação de desastres ou fazer a transição de bancos de dados autogerenciados. São cenários comuns migrar de servidores do MariaDB auto-hospedados para instâncias de banco de dados do Amazon RDS totalmente gerenciadas, consolidar vários bancos de dados MariaDB em uma única instância de banco de dados ou criar ambientes de teste com dados de produção. As seções a seguir apresentam instruções detalhadas sobre como importar dados do MariaDB usando métodos, como `mariadb-dump`, arquivos de backup ou replicação.
## Etapa 1: Criar arquivos simples contendo os dados a serem carregados
Use um formato comum, como valores separados por vírgula (CSV), para armazenar os dados a serem carregados. Cada tabela deve ter um arquivo próprio. Não é possível combinar os dados de várias tabelas no mesmo arquivo. Dê a cada arquivo o mesmo nome que a tabela correspondente. A extensão do arquivo pode ser qualquer opção desejada. Por exemplo, se o nome da tabela for `sales`, o nome do arquivo poderá ser `sales.csv` ou `sales.txt`.
Se possível, ordene os dados pela chave primária da tabela que está sendo carregada. Fazer isso melhora drasticamente os tempos de carregamento e minimiza os requisitos de armazenamento em disco.
A velocidade e a eficiência desse procedimento dependem de manter o tamanho dos arquivos pequenos. Se o tamanho descompactado de qualquer arquivo individual for maior que 1 GiB, divida-o em vários arquivos e carregue cada um separadamente.
Em sistemas semelhantes ao Unix (incluindo o Linux), use o comando `split`. Por exemplo, o seguinte comando divide o arquivo `sales.csv` em vários arquivos com menos de 1 GiB, dividindo apenas em intervalos de linha (-C 1024m). Os nomes dos novos arquivos incluem sufixos numéricos ascendentes. O comando a seguir produz arquivos com nomes, como `sales.part_00` e `sales.part_01`.
```
split -C 1024m -d sales.csv sales.part_
```
Utilitários semelhantes estão disponíveis para outros sistemas operacionais.
Você pode armazenar os arquivos simples em qualquer lugar. No entanto, ao carregar os dados na [Etapa 5](#mariadb-importing-data-any-source-load-data), você deve invocar o shell `mysql` do mesmo local em que os arquivos estão ou usar o caminho absoluto para os arquivos ao executar `LOAD DATA LOCAL INFILE`.
## Etapa 2: impedir que quaisquer aplicações acessem a instância de banco de dados de destino
Antes de iniciar um grande carregamento, impeça que qualquer atividade da aplicação acesse a instância de banco de dados de destino para a qual planeja fazer o carregamento. Recomendamos isso especialmente se outras sessões modificarem as tabelas que estão sendo carregadas ou as tabelas às quais elas fazem referência. Isso reduz o risco de violações de restrição durante o carregamento e melhora a performance do carregamento. Também possibilita restaurar a instância de banco de dados até o ponto antes do carregamento, sem perder as alterações feitas pelos processos não envolvidos no carregamento.
É que isso pode não ser possível ou prático. Se você não conseguir impedir que as aplicações acessem a instância de banco de dados antes do carregamento, tome medidas para garantir a disponibilidade e a integridade dos seus dados. As etapas específicas necessárias variam muito dependendo dos casos específicos de uso e dos requisitos do site.
## Etapa 3: Criar um snapshot de banco de dados
Se você planeja carregar dados em uma nova instância de banco de dados que não contém dados, pode ignorar essa etapa. Do contrário, recomendamos criar snapshots de banco de dados da instância de banco de dados de destino do Amazon RDS antes e depois do carregamento dos dados. Os snapshots de banco de dados do Amazon RDS são backups completos da instância de banco de dados que podem ser usados para restaurá-la em um estado conhecido. Quando você inicia um snapshot de banco de dados, as operações de E/S na sua instância de banco de dados são momentaneamente suspensas enquanto é feito o backup do banco de dados.
Criar um snapshot de banco de dados imediatamente antes do carregamento possibilita a restauração do banco de dados para o estado anterior ao carregamento, se necessário. Um snapshot de banco de dados feito imediatamente após a carga evita que você tenha que carregar os dados novamente caso ocorra um problema. Você também pode usar snapshots de banco de dados após o carregamento para importar dados para novas instâncias de banco de dados.
O exemplo a seguir executa o comando [create-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/create-db-snapshot.html) da AWS CLI para criar um snapshot de banco de dados da instância `AcmeRDS` e fornece ao snapshot do banco de dados o identificador `"preload"`.
Para Linux, macOS ou Unix:
```
aws rds create-db-snapshot \
--db-instance-identifier AcmeRDS \
--db-snapshot-identifier preload
```
Para Windows:
```
aws rds create-db-snapshot ^
--db-instance-identifier AcmeRDS ^
--db-snapshot-identifier preload
```
Você também pode usar a restauração da funcionalidade de snapshot do banco de dados para criar instâncias de banco de dados de teste para execuções simuladas ou para desfazer alterações feitas durante o carregamento.
Tenha em mente que restaurar um banco de dados de um snapshot de banco de dados cria uma nova instância de banco de dados que, como todas as instâncias de banco de dados, possui um identificador exclusivo e um endpoint. Para restaurar a instância de banco de dados sem alterar o endpoint, primeiro exclua a instância de banco de dados para poder reutilizar o endpoint.
Por exemplo, para criar uma instância de banco de dados para execuções simuladas ou outros testes, forneça à instância de banco de dados um identificador próprio. Na exemplo, o identificador é `AcmeRDS-2`. O exemplo se conecta à instância de banco de dados usando o endpoint associado ao `AcmeRDS-2`. Para ter mais informações, consulte [restore-db-instance-from-db-snapshot](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html).
Para Linux, macOS ou Unix:
```
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier AcmeRDS-2 \
--db-snapshot-identifier preload
```
Para Windows:
```
aws rds restore-db-instance-from-db-snapshot ^
--db-instance-identifier AcmeRDS-2 ^
--db-snapshot-identifier preload
```
Para reutilizar o endpoint existente, primeiro exclua a instância de banco de dados e forneça ao banco de dados restaurado o mesmo identificador. Para ter mais informações, consulte [delete-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/delete-db-instance.html).
O exemplo a seguir também cria um snapshot de banco de dados final da instância de banco de dados antes de excluí-la. Isso é opcional, porém é recomendado.
Para Linux, macOS ou Unix:
```
aws rds delete-db-instance \
--db-instance-identifier AcmeRDS \
--final-db-snapshot-identifier AcmeRDS-Final
aws rds restore-db-instance-from-db-snapshot \
--db-instance-identifier AcmeRDS \
--db-snapshot-identifier preload
```
Para Windows:
```
aws rds delete-db-instance ^
--db-instance-identifier AcmeRDS ^
--final-db-snapshot-identifier AcmeRDS-Final
aws rds restore-db-instance-from-db-snapshot ^
--db-instance-identifier AcmeRDS ^
--db-snapshot-identifier preload
```
## Etapa 4 (opcional): desativar os backups automatizados do Amazon RDS
**Atenção**
Não desative os backups automatizados se você precisa realizar uma recuperação para um ponto no tempo.
A desativação de backups automatizados ajuda a otimizar a performance e não é necessária para carregamentos de dados. Ao desativar os backups automatizados, todos os backups existentes são apagados. Consequentemente, após a desativação dos backups automatizados, não é possível realizar uma recuperação para um ponto no tempo. Os snapshots do banco de dados manuais não são afetados com a desativação dos backups automatizados. Todos os snapshots de banco de dados manuais existentes ainda estão disponíveis para restauração.
Desativar os backups automatizados reduz o tempo de carregamento em cerca de 25% e reduz a quantidade de espaço de armazenamento necessária durante o carregamento. Se você planeja carregar dados em uma nova instância de banco de dados que não contém dados, desativar os backups é uma maneira fácil de acelerar o carregamento e evitar o uso do armazenamento adicional necessário para backups. No entanto, em alguns casos, você pode planejar fazer o carregamento em uma instância de banco de dados que já contenha dados. Se for o caso, avalie os benefícios da desativação de backups em relação ao impacto da perda da capacidade de realizar a recuperação em um ponto anterior no tempo.
As instâncias de bancos de dados têm backups automatizados desativados por padrão (com um período de retenção de um dia). Para desatiar os backups automáticos, defina o período de retenção de backup para zero. Após o carregamento, você pode reativar os backups definindo o período de retenção de backup como um valor diferente de zero. Para ativar ou desativar os backups, o Amazon RDS desliga a instância de banco de dados e a reinicia para ativar ou desativar o registro em log do MariaDB.
Execute o comando AWS CLI da `modify-db-instance` para definir a retenção do backup como zero e aplicar a alteração imediatamente. Definir o período de retenção como zero exige uma reinicialização da instância de banco de dados. Por isso, aguarde até que a reinicialização tenha sido concluída antes de prosseguir. Para obter mais informações, consulte [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html).
Para Linux, macOS ou Unix:
```
aws rds modify-db-instance \
--db-instance-identifier AcmeRDS \
--apply-immediately \
--backup-retention-period 0
```
Para Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier AcmeRDS ^
--apply-immediately ^
--backup-retention-period 0
```
Você pode conferir o status sua instância de banco de dados com o comando [describe-db-instances](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-instances.html). O seguinte exemplo mostra o status da instância de banco de dados `AcmeRDS`:
```
aws rds describe-db-instances --db-instance-identifier AcmeRDS --query "*[].{DBInstanceStatus:DBInstanceStatus}"
```
Quando o status da instância de banco de dados for `available`, você poderá prosseguir para a próxima etapa.
## Etapa 5: Carregar os dados
Para ler as linhas dos arquivos simples nas tabelas do banco de dados, use a instrução `LOAD DATA LOCAL INFILE` do MariaDB.
**nota**
Você deve invocar o shell `mariadb` do mesmo local em que seus arquivos simples estão ou usar o caminho absoluto para os arquivos ao executar `LOAD DATA LOCAL INFILE`.
O seguinte exemplo mostra como carregar dados de um arquivo chamado `sales.txt` em uma tabela denominada `Sales` no banco de dados:
```
MariaDB [(none)]> LOAD DATA LOCAL INFILE 'sales.txt' INTO TABLE Sales FIELDS TERMINATED BY ' ' ENCLOSED BY '' ESCAPED BY '\\';
Query OK, 1 row affected (0.01 sec)
Records: 1 Deleted: 0 Skipped: 0 Warnings: 0
```
Para acessar mais informações sobre a instrução `LOAD DATA`, consulte [LOAD DATA INFILE](https://mariadb.com/docs/server/reference/sql-statements/data-manipulation/inserting-loading-data/load-data-into-tables-or-index/load-data-infile) na documentação do MariaDB.
## Etapa 6: reativar os backups automatizados do Amazon RDS
Se você desativou os backups automatizados do Amazon RDS na [Etapa 4](#mariadb-importing-data-any-source-turn-off-automated-backups), depois que o carregamento for concluído, ative os backups automatizados definindo o período de retenção de backup de volta como o valor anterior ao carregamento. Conforme mencionado na Etapa 4, como o Amazon RDS reinicia a instância de banco de dados, prepare-se para uma breve interrupção.
O seguinte exemplo executa o comando [modify-db-instance](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) da AWS CLI para ativar os backups automatizados da instância de banco de dados `AcmeRDS` e define o período de retenção para um dia:
Para Linux, macOS ou Unix:
```
aws rds modify-db-instance \
--db-instance-identifier AcmeRDS \
--backup-retention-period 1 \
--apply-immediately
```
Para Windows:
```
aws rds modify-db-instance ^
--db-instance-identifier AcmeRDS ^
--backup-retention-period 1 ^
--apply-immediately
```
# Como trabalhar com a replicação do MariaDB no Amazon RDS
Normalmente, você usa réplicas de leitura para configurar a replicação entre as instâncias de banco de dados do Amazon RDS. Para obter informações gerais sobre réplicas de leitura, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md). Para obter informações específicas sobre como trabalhar com réplicas de leitura no Amazon RDS para MariaDB, consulte [Trabalhar com réplicas de leitura do MariaDB](USER_MariaDB.Replication.ReadReplicas.md).
Você também pode configurar a replicação com base nas coordenadas do log binário para as instâncias de banco de dados MariaDB. Para as instâncias do MariaDB, você também pode configurar a replicação com base nos IDs de transações globais (GTIDs), o que oferece uma melhor segurança contra falhas. Para obter mais informações, consulte [Configurar a replicação baseada em GTID com uma instância de origem externa](MariaDB.Procedural.Replication.GTID.md).
Estas são as outras opções de replicação disponíveis com o RDS para MariaDB:
+ É possível configurar a replicação entre uma instância de banco de dados do RDS para MariaDB e uma instância do MySQL ou do MariaDB externa ao Amazon RDS. Para obter informações sobre como configurar a replicação com uma origem externa, consulte [Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa](MySQL.Procedural.Importing.External.ReplMariaDB.md).
+ Você pode configurar a replicação para importar bancos de dados de uma instância MySQL ou do MariaDB externos ao Amazon RDS, ou exportar bancos de dados para essas instâncias. Para obter mais informações, consulte [Importar dados para uma instância de banco de dados do Amazon RDS para MariaDB com tempo de inatividade reduzido](mariadb-importing-data-reduced-downtime.md) e [Exportar dados de uma instância de banco de dados MySQL usando replicação](MySQL.Procedural.Exporting.NonRDSRepl.md).
Para todas essas opções de replicação, use replicação baseada em linha, em instrução ou mista. A replicação baseada em linha só replica as linhas alteradas resultantes de uma instrução SQL. A replicação baseada em instrução copia toda a instrução SQL. A replicação mista usa uma replicação baseada em instrução quando possível, mas alterna para replicação baseada em linha quando as instruções SQL não seguras para replicação baseada em instrução são executadas. Na maioria dos casos, a replicação mista é recomendada. O formato de log binário da instância de banco de dados determina se a replicação se baseia na linha, na instrução ou mista. Para obter informações sobre como definir o formato de log binário, consulte [Configurar o registro em log binário do MariaDB](USER_LogAccess.MariaDB.BinaryFormat.md).
Para obter informações sobre a compatibilidade de replicação entre as versões do MariaDB, consulte [Compatibilidade de replicação](https://mariadb.com/kb/en/mariadb-vs-mysql-compatibility/#replication-compatibility) na documentação do MariaDB.
**Topics**
+ [Trabalhar com réplicas de leitura do MariaDB](USER_MariaDB.Replication.ReadReplicas.md)
+ [Configurar a replicação baseada em GTID com uma instância de origem externa](MariaDB.Procedural.Replication.GTID.md)
+ [Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa](MySQL.Procedural.Importing.External.ReplMariaDB.md)
# Trabalhar com réplicas de leitura do MariaDB
Encontre a seguir informações específicas sobre como trabalhar com réplicas de leitura no Amazon RDS para MariaDB. Para obter informações gerais sobre as réplicas de leitura e as instruções de como usá-las, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
+ [Configurar filtros de replicação com o MariaDB](USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.md)
+ [Configurar a replicação atrasada com o MariaDB](USER_MariaDB.Replication.ReadReplicas.DelayReplication.md)
+ [Atualizar réplicas de leitura com o MariaDB](USER_MariaDB.Replication.ReadReplicas.Updates.md)
+ [Trabalhar com implantações de réplicas de leitura multi-AZ com o MariaDB](USER_MariaDB.Replication.ReadReplicas.MultiAZ.md)
+ [Usar réplicas de leitura em cascata com o RDS para MariaDB](USER_MariaDB.Replication.ReadReplicas.Cascading.md)
+ [Monitoramento de réplicas de leitura do MariaDB](USER_MariaDB.Replication.ReadReplicas.Monitor.md)
+ [Início e interrupção de replicação com réplicas de leitura do MariaDB](USER_MariaDB.Replication.ReadReplicas.StartStop.md)
+ [Solução de problemas da réplica de leitura do MariaDB](USER_ReadRepl.Troubleshooting.MariaDB.md)
## Configurar réplicas de leitura com o MariaDB
Para que uma instância de banco de dados do MariaDB possa servir como uma fonte de replicação, você deve ativar os backups automáticos na instância de banco de dados de origem definindo o período de retenção do backup como um valor diferente de 0. Esse requisito também se aplica a uma réplica de leitura que seja a instância de banco de dados de origem de outra réplica de leitura.
Você pode criar até quinze réplicas de leitura de uma instância de banco de dados na mesma região. Para que a replicação funcione efetivamente, cada réplica de leitura deve ter a mesma quantidade de recursos de computação e armazenamento que a instância de banco de dados de origem. Se você dimensionar a instância de banco de dados de origem, dimensione as réplicas de leitura também.
O RDS para MariaDB é compatível com réplicas de leitura em cascata. Para saber mais sobre como configurar réplicas de leitura em cascata, consulte [Usar réplicas de leitura em cascata com o RDS para MariaDB](USER_MariaDB.Replication.ReadReplicas.Cascading.md).
É possível executar várias ações simultâneas de criação ou exclusão de réplicas de leitura que fazem referência à mesma instância de banco de dados de origem. Ao realizar essas ações, permaneça dentro do limite de quinze réplicas de leitura para cada instância de origem.
# Configurar filtros de replicação com o MariaDB
Você pode usar filtros de replicação para especificar quais bancos de dados e tabelas são replicados com uma réplica de leitura. Os filtros de replicação podem incluir bancos de dados e tabelas na replicação ou excluí-los da replicação.
Veja a seguir alguns casos de uso para filtros de replicação:
+ Para reduzir o tamanho de uma réplica de leitura. Com a filtragem de replicação, você pode excluir os bancos de dados e tabelas que não são necessários na réplica de leitura.
+ Para excluir bancos de dados e tabelas de réplicas de leitura por motivos de segurança.
+ Para replicar diferentes bancos de dados e tabelas para casos de uso específicos em diferentes réplicas de leitura. Por exemplo, você pode usar réplicas de leitura específicas para análise ou fragmentação.
+ Para uma instância de banco de dados que tenha réplicas de leitura em diferentes Regiões da AWS, para replicar diferentes bancos de dados ou tabelas em diferentes Regiões da AWS.
**nota**
É possível usar filtros de replicação para especificar quais bancos de dados e tabelas serão replicados com uma instância de banco de dados primária do MariaDB configurada como uma réplica em uma topologia de replicação de entrada. Para obter mais informações sobre essa configuração, consulte [Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa](MySQL.Procedural.Importing.External.Repl.md).
**Topics**
+ [Definir parâmetros de filtragem de replicação do RDS para MariaDB](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Configuring)
+ [banco de dados primário filtragem de replicação do RDS para MariaDB](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Limitations)
+ [Exemplos de filtragem de replicação no RDS para MariaDB](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Examples)
+ [Visualizar os filtros de replicação para uma réplica de leitura](#USER_MariaDB.Replication.ReadReplicas.ReplicationFilters.Viewing)
## Definir parâmetros de filtragem de replicação do RDS para MariaDB
Para configurar filtros de replicação, defina os seguintes parâmetros de filtragem de replicação na réplica de leitura:
+ `replicate-do-db` – Replicar alterações nos bancos de dados especificados. Quando você define esse parâmetro para uma réplica de leitura, somente os bancos de dados especificados no parâmetro são replicados.
+ `replicate-ignore-db` – Não replique as alterações nos bancos de dados especificados. Quando o parâmetro `replicate-do-db` é definido para uma réplica de leitura, esse parâmetro não é avaliado.
+ `replicate-do-table` – Replicar alterações nas tabelas especificadas. Quando você define esse parâmetro para uma réplica de leitura, somente as tabelas especificadas no parâmetro são replicadas. Além disso, quando o parâmetro `replicate-do-db` ou `replicate-ignore-db` é definido, o banco de dados que inclui as tabelas especificadas deve ser incluído na replicação com a réplica de leitura.
+ `replicate-ignore-table` – Não replique as alterações nas tabelas especificadas. Quando o parâmetro `replicate-do-table` é definido para uma réplica de leitura, esse parâmetro não é avaliado.
+ `replicate-wild-do-table` – Replicar tabelas com base nos padrões de nome de banco de dados e tabela especificados. Os caracteres curinga `%` e `_` são compatíveis. Quando o parâmetro `replicate-do-db` ou `replicate-ignore-db` estiver definido, certifique-se de incluir o banco de dados que inclui as tabelas especificadas na replicação com a réplica de leitura.
+ `replicate-wild-ignore-table` – Não replique tabelas com base nos padrões de nome de banco de dados e tabela especificados. Os caracteres curinga `%` e `_` são compatíveis. Quando o parâmetro `replicate-do-table` ou `replicate-wild-do-table` é definido para uma réplica de leitura, esse parâmetro não é avaliado.
Os parâmetros são avaliados na ordem em que estão listados. Para obter mais informações sobre como esses parâmetros funcionam, consulte [a documentação do MariaDB](https://mariadb.com/kb/en/replication-filters/#replication-filters-for-replication-slaves).
Por padrão, cada um desses parâmetros tem um valor vazio. Em cada réplica de leitura, você pode usar esses parâmetros para definir, alterar e excluir filtros de replicação. Quando você define um desses parâmetros, separe cada filtro dos outros com uma vírgula.
Você pode usar `%` os caracteres curinga `_` e nos parâmetros `replicate-wild-do-table` e `replicate-wild-ignore-table`. O curinga `%` corresponde a qualquer número de caracteres e o caractere curinga `_` corresponde apenas a um caractere.
O formato de log binário da instância de banco de dados de origem é importante para replicação porque determina o registro de alterações de dados. A configuração do parâmetro `binlog_format` determina se a replicação é baseada em linha ou baseada em declaração. Para obter mais informações, consulte [Configurar o registro em log binário do MariaDB](USER_LogAccess.MariaDB.BinaryFormat.md).
**nota**
Todas as instruções DDL (Data Definition Language, linguagem de definição de dados) são replicadas como instruções, independentemente da `binlog_format` configuração na instância de banco de dados de origem.
## banco de dados primário filtragem de replicação do RDS para MariaDB
As seguintes limitações se aplicam à filtragem de replicação do RDS para MariaDB:
+ Cada parâmetro de filtragem de replicação tem um limite de 2.000 caracteres.
+ As vírgulas não são compatíveis em filtros de replicação.
+ As opções `binlog_do_db` e `binlog_ignore_db` do MariaDB para filtragem de log binário não são compatíveis.
+ A filtragem de replicação não suporta transações XA.
Para obter mais informações, consulte [Restrictions on XA Transactions](https://dev.mysql.com/doc/refman/8.0/en/xa-restrictions.html) na documentação do MySQL.
+ A filtragem de replicação não é compatível com o RDS para MariaDB versão 10.2.
## Exemplos de filtragem de replicação no RDS para MariaDB
Para configurar a filtragem de replicação para uma réplica de leitura, modifique os parâmetros de filtragem de replicação no grupo de parâmetros associado à réplica de leitura.
**nota**
Não é possível modificar um grupo de parâmetros padrão. Se a réplica de leitura estiver usando um grupo de parâmetros padrão, crie um novo grupo de parâmetros e o associe à instância de banco de dados. Para obter mais informações sobre grupos de parâmetros de banco de dados, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
Você pode definir parâmetros em um grupo de parâmetros usando a Console de gerenciamento da AWS, a AWS CLI ou a API do RDS. Para obter informações sobre como configurar parâmetros, consulte [Modificar parâmetros em um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Modifying.md). Quando você define parâmetros em um grupo de parâmetros, todas as instâncias de banco de dados associadas ao grupo de parâmetros usam as configurações de parâmetro. Se você definir os parâmetros de filtragem de replicação em um grupo de parâmetros, verifique se o grupo de parâmetros está associado apenas a réplicas de leitura. Deixe os parâmetros de filtragem de replicação vazios para instâncias de banco de dados de origem.
Os exemplos a seguir definem os parâmetros usando o AWS CLI. Estes exemplos definem `ApplyMethod` para `immediate` de modo que as mudanças do parâmetro ocorram imediatamente depois que o comando CLI termina. Se você quiser que uma alteração pendente seja aplicada depois que a réplica de leitura for reinicializada, defina como `ApplyMethod` `pending-reboot`.
Os exemplos a seguir definem filtros de replicação:
+ [Including databases in replication](#rep-filter-in-dbs-mariadb)
+ [Including tables in replication](#rep-filter-in-tables-mariadb)
+ [Including tables in replication with wildcard characters](#rep-filter-in-tables-wildcards-mariadb)
+ [Escaping wildcard characters in names](#rep-filter-escape-wildcards-mariadb)
+ [Excluding databases from replication](#rep-filter-ex-dbs-mariadb)
+ [Excluding tables from replication](#rep-filter-ex-tables-mariadb)
+ [Excluding tables from replication using wildcard characters](#rep-filter-ex-tables-wildcards-mariadb)
**Example Incluir bancos de dados em replicação**
O exemplo a seguir inclui os bancos de dados `mydb1` e `mydb2` na replicação. Quando você define `replicate-do-db` para uma réplica de leitura, somente os bancos de dados especificados no parâmetro são replicados.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "[{"ParameterName": "replicate-do-db", "ParameterValue": "mydb1,mydb2", "ApplyMethod":"immediate"}]"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-do-db", "ParameterValue": "mydb1,mydb2", "ApplyMethod":"immediate"}]"
```
**Example Incluir tabelas na replicação**
O exemplo a seguir inclui as tabelas `table1` e `table2` no banco de dados `mydb1` na replicação.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "[{"ParameterName": "replicate-do-table", "ParameterValue": "mydb1.table1,mydb1.table2", "ApplyMethod":"immediate"}]"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-do-table", "ParameterValue": "mydb1.table1,mydb1.table2", "ApplyMethod":"immediate"}]"
```
**Example Incluir tabelas na replicação usando caracteres curinga**
O exemplo a seguir inclui tabelas com nomes que começam com `orders` e `returns` no banco de dados `mydb` na replicação.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "[{"ParameterName": "replicate-wild-do-table", "ParameterValue": "mydb.orders%,mydb.returns%", "ApplyMethod":"immediate"}]"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-wild-do-table", "ParameterValue": "mydb.orders%,mydb.returns%", "ApplyMethod":"immediate"}]"
```
**Example Caracteres de escape curinga em nomes**
O exemplo a seguir mostra como usar o caractere de escape `\` para liberar um caractere curinga que faz parte de um nome.
Suponha que você tenha vários nomes de tabela no banco de dados `mydb1` que começam com `my_table`, e você deseja incluir essas tabelas na replicação. Os nomes das tabelas incluem um sublinhado, que também é um caractere curinga, portanto, o exemplo escapa ao sublinhado nos nomes das tabelas.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "[{"ParameterName": "replicate-wild-do-table", "ParameterValue": "my\_table%", "ApplyMethod":"immediate"}]"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-wild-do-table", "ParameterValue": "my\_table%", "ApplyMethod":"immediate"}]"
```
**Example Excluir bancos de dados da replicação**
O exemplo a seguir exclui os bancos de dados `mydb1` e `mydb2` da replicação.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "[{"ParameterName": "replicate-ignore-db", "ParameterValue": "mydb1,mydb2", "ApplyMethod":"immediate"}]"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-ignore-db", "ParameterValue": "mydb1,mydb2", "ApplyMethod":"immediate"}]"
```
**Example Excluir tabelas da replicação**
O exemplo a seguir exclui tabelas `table1` e `table2` no banco de dados `mydb1` da replicação.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "[{"ParameterName": "replicate-ignore-table", "ParameterValue": "mydb1.table1,mydb1.table2", "ApplyMethod":"immediate"}]"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-ignore-table", "ParameterValue": "mydb1.table1,mydb1.table2", "ApplyMethod":"immediate"}]"
```
**Example Excluir tabelas da replicação usando caracteres curinga**
O exemplo a seguir exclui tabelas com nomes que começam com `orders` e `returns` no banco de dados `mydb` da replicação.
Para Linux, macOS ou Unix:
```
aws rds modify-db-parameter-group \
--db-parameter-group-name myparametergroup \
--parameters "[{"ParameterName": "replicate-wild-ignore-table", "ParameterValue": "mydb.orders%,mydb.returns%", "ApplyMethod":"immediate"}]"
```
Para Windows:
```
aws rds modify-db-parameter-group ^
--db-parameter-group-name myparametergroup ^
--parameters "[{"ParameterName": "replicate-wild-ignore-table", "ParameterValue": "mydb.orders%,mydb.returns%", "ApplyMethod":"immediate"}]"
```
## Visualizar os filtros de replicação para uma réplica de leitura
Você pode visualizar os filtros de replicação de uma réplica de leitura das seguintes maneiras:
+ Verifique as configurações dos parâmetros de filtragem de replicação no grupo de parâmetros associado à réplica de leitura.
Para obter instruções, consulte [Visualizar valores de parâmetros para um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Viewing.md).
+ Em um cliente MariaDB, conecte-se à réplica de leitura e execute a instrução `SHOW REPLICA STATUS`.
Na saída, os campos a seguir mostram os filtros de replicação para a réplica de leitura:
+ `Replicate_Do_DB`
+ `Replicate_Ignore_DB`
+ `Replicate_Do_Table`
+ `Replicate_Ignore_Table`
+ `Replicate_Wild_Do_Table`
+ `Replicate_Wild_Ignore_Table`
Para obter mais informações sobre esses campos, consulte [Verificar o status da replicação](https://dev.mysql.com/doc/refman/8.0/en/replication-administration-status.html) na documentação do MySQL.
**nota**
Versões anteriores do MariaDB usavam `SHOW SLAVE STATUS` em vez de `SHOW REPLICA STATUS`. Se você estiver usando uma versão do MariaDB anterior à 10.5, use `SHOW SLAVE STATUS`.
# Configurar a replicação atrasada com o MariaDB
Você pode usar a replicação atrasada como uma estratégia para a recuperação de desastres. Com a replicação atrasada, você especifica o tempo mínimo, em segundos, para atrasar a replicação da origem para a réplica de leitura. Em caso de um desastre, como uma tabela excluída acidentalmente, você executa as seguintes etapas para recuperar-se rapidamente do desastre:
+ Interrompa a replicação da réplica de leitura antes que a alteração que causou o desastre seja enviada para ela.
Use o procedimento armazenado [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) para interromper a replicação.
+ Promova a réplica de leitura para ser a nova instância de banco de dados de origem usando as instruções em [Promoção de uma réplica de leitura a uma instância de banco de dados autônoma](USER_ReadRepl.Promote.md).
**nota**
A replicação atrasada é compatível com o MariaDB 10.6 e posteriores.
Use procedimentos armazenados para configurar a replicação atrasada. Você não pode configurar a replicação atrasada com o Console de gerenciamento da AWS, a AWS CLI ou a API do Amazon RDS.
Você pode usar a replicação com base em identificadores de transação global (GTIDs) em uma configuração de replicação atrasada.
**Topics**
+ [Configurar replicação atrasada durante a criação da réplica de leitura](#USER_MariaDB.Replication.ReadReplicas.DelayReplication.ReplicaCreation)
+ [Modificar replicação atrasada de uma réplica de leitura existente](#USER_MariaDB.Replication.ReadReplicas.DelayReplication.ExistingReplica)
+ [Promover uma réplica de leitura](#USER_MariaDB.Replication.ReadReplicas.DelayReplication.Promote)
## Configurar replicação atrasada durante a criação da réplica de leitura
Para configurar a replicação atrasada para qualquer réplica de leitura futura criada a partir de uma instância de banco de dados, execute o procedimento armazenado [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) com o parâmetro `target delay`.
**Para configurar a replicação atrasada durante a criação da réplica de leitura**
1. Usando um cliente MariaDB, conecte-se à instância de banco de dados MariaDB que será a origem para réplicas de leitura como o usuário primário.
1. Execute o procedimento armazenado [mysql.rds\$1set\$1configuration](mysql-stored-proc-configuring.md#mysql_rds_set_configuration) com o parâmetro `target delay`.
Por exemplo, execute o procedimento armazenado a seguir para especificar que a replicação é atrasada em pelo menos uma hora (3,600 segundos) para qualquer réplica de leitura criada a partir da instância de banco de dados atual.
```
call mysql.rds_set_configuration('target delay', 3600);
```
**nota**
Após executar esse procedimento armazenado, qualquer réplica de leitura que você criar usando a AWS CLI ou a API do Amazon RDS será configurada com a replicação atrasada pelo número de segundos especificado.
## Modificar replicação atrasada de uma réplica de leitura existente
Para modificar a replicação atrasada para uma réplica de leitura existente, execute o procedimento armazenado [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay).
**Para modificar a replicação atrasada para uma réplica de leitura existente**
1. Usando um cliente do MariaDB, conecte-se à réplica de leitura como o usuário primário.
1. Use o procedimento armazenado [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) para interromper a replicação.
1. Execute o procedimento armazenado [mysql.rds\$1set\$1source\$1delay](mysql-stored-proc-replicating.md#mysql_rds_set_source_delay).
Por exemplo, execute o procedimento armazenado a seguir para especificar que a replicação para a réplica de leitura é atrasada em pelo menos uma hora (3.600 segundos) para qualquer réplica de leitura criada a partir da instância de banco de dados atual.
```
call mysql.rds_set_source_delay(3600);
```
1. Use o procedimento armazenado [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) para iniciar a replicação.
## Promover uma réplica de leitura
Após a replicação ser interrompida, em um cenário de recuperação de desastres, você pode promover uma réplica de leitura para ser a nova instância de banco de dados de origem. Para obter informações sobre como promover uma réplica de leitura, consulte [Promoção de uma réplica de leitura a uma instância de banco de dados autônoma](USER_ReadRepl.Promote.md).
# Atualizar réplicas de leitura com o MariaDB
As réplicas de leitura foram projetadas para oferecer suporte a consultas de leitura, mas você pode precisar fazer atualizações ocasionais. Por exemplo, talvez seja necessário adicionar um índice para acelerar tipos específicos de consultas que acessam a réplica. Você pode habilitar as atualizações configurando o parâmetro `read_only` como **0** no grupo de parâmetros de banco de dados da réplica de leitura.
# Trabalhar com implantações de réplicas de leitura multi-AZ com o MariaDB
É possível criar uma réplica de leitura a partir de implantações de instâncias de banco de dados single-AZ ou multi-AZ. Você pode usar implantações multi-AZ para melhorar a durabilidade e a disponibilidade de dados essenciais. No entanto, não é possível usar o multi-AZ secundário para atender a consultas somente leitura. Em vez disso, crie réplicas de leitura de instâncias de banco de dados multi-AZ de alto tráfego para descarregar consultas somente leitura. Se a instância de origem de uma implantação multi-AZ falhar na secundária, todas as réplicas de leitura associadas serão automaticamente alteradas para usar a secundária (não a primária) como a origem de replicação. Para obter mais informações, consulte [Configurar e gerenciar uma implantação multi-AZ para o Amazon RDS](Concepts.MultiAZ.md).
É possível criar uma réplica de leitura como uma instância de banco de dados multi-AZ. O Amazon RDS cria um em modo de espera de sua réplica em outra zona de disponibilidade para suporte a failover da réplica. Você pode criar a réplica de leitura como uma instância de banco de dados multi-AZ independentemente de o banco de dados de origem ser ou não uma instância de banco de dados multi-AZ.
# Usar réplicas de leitura em cascata com o RDS para MariaDB
O RDS para MariaDB é compatível com réplicas de leitura em cascata. Com *réplicas de leitura em cascata*, é possível escalar leituras sem adicionar sobrecarga à instância de banco de dados do RDS para MariaDB de origem.
Com réplicas de leitura em cascata, sua instância de banco de dados do RDS para MariaDB envia dados para a primeira réplica de leitura da cadeia. Essa réplica de leitura envia dados para a segunda réplica na cadeia e assim por diante. O resultado final é que todas as réplicas de leitura na cadeia têm as alterações da instância de banco de dados do RDS para MariaDB, mas sem a sobrecarga apenas na instância de banco de dados de origem.
É possível criar uma série de até três réplicas de leitura em uma cadeia de uma instância de banco de dados de origem do RDS para MariaDB. Por exemplo, suponha que você tenha uma instância de banco de dados do RDS para MariaDB, `mariadb-main`. Você pode fazer o seguinte:
+ Começando com `mariadb-main`, crie a primeira réplica de leitura na cadeia, `read-replica-1`.
+ Na `read-replica-1`, crie a próxima réplica de leitura na cadeia, `read-replica-2`.
+ Finalmente, na `read-replica-2`, crie a terceira réplica de leitura na cadeia, `read-replica-3`.
Não é possível criar outra réplica de leitura além dessa terceira réplica de leitura em cascata na série de `mariadb-main`. Uma série completa de instâncias de uma instância de banco de dados de origem do RDS para MariaDB até o final de uma série de réplicas de leitura em cascata pode consistir em, no máximo, quatro instâncias de banco de dados.
Para que as réplicas de leitura em cascata funcionem, cada instância de banco de dados do RDS para MariaDB de origem deve ter os backups automatizados ativados. Para ativar backups automáticos em uma réplica de leitura, primeiro crie a réplica de leitura e a modifique para ativar backups automáticos. Para ter mais informações, consulte [Como criar uma réplica de leitura](USER_ReadRepl.Create.md).
Como em qualquer réplica de leitura, é possível promover uma réplica de leitura que faz parte de uma cascata. A promoção de uma réplica de leitura de uma cadeia de réplicas de leitura remove essa réplica da cadeia. Por exemplo, suponha que você queira mover parte da workload da instância de banco de dados `mariadb-main` para uma nova instância para uso somente pelo departamento de contabilidade. Pressupondo a cadeia com três réplicas de leitura do exemplo, você decide promover `read-replica-2`. A cadeia é afetada da seguinte forma:
+ A promoção de `read-replica-2` a remove da cadeia de replicação.
+ Ela agora é uma instância de banco de dados de leitura/gravação completa.
+ Ela continua replicando para `read-replica-3`, da mesma forma como estava fazendo antes da promoção.
+ A `mariadb-main` continua a replicar para a `read-replica-1`.
Para obter mais informações sobre como promover réplicas de leitura, consulte [Promoção de uma réplica de leitura a uma instância de banco de dados autônoma](USER_ReadRepl.Promote.md).
# Monitoramento de réplicas de leitura do MariaDB
Para as réplicas de leitura do MariaDB, você pode monitorar o atraso da replicação no Amazon CloudWatch visualizando a métrica `ReplicaLag` do Amazon RDS. A métrica `ReplicaLag` relata o valor do campo `Seconds_Behind_Master` do comando `SHOW REPLICA STATUS`.
**nota**
Versões anteriores do MariaDB usavam `SHOW SLAVE STATUS` em vez de `SHOW REPLICA STATUS`. Se você estiver usando uma versão do MariaDB anterior à 10.5, use `SHOW SLAVE STATUS`.
As causas comuns para o atraso da replicação do MariaDB são as seguintes:
+ Uma queda de rede.
+ Gravar em tabelas com índices em uma réplica de leitura. Se o parâmetro `read_only` não estiver definido como 0 na réplica de leitura, isso poderá interromper a replicação.
+ Uso de um mecanismo de armazenamento não transacional, como o MyISAM. A replicação só é compatível com o mecanismo de armazenamento InnoDB no MariaDB.
Quando a métrica `ReplicaLag` chega a 0, isso mostra que a réplica alcançou a instância do banco de dados de origem. Se a métrica `ReplicaLag` retornar -1, então a replicação não está ativa no momento. `ReplicaLag` = -1 é equivalente a `Seconds_Behind_Master` = `NULL`.
# Início e interrupção de replicação com réplicas de leitura do MariaDB
Você pode interromper e reiniciar o processo de replicação em uma instância de banco de dados do Amazon RDS ao chamar os procedimentos armazenados do sistema [mysql.rds\$1stop\$1replication](mysql-stored-proc-replicating.md#mysql_rds_stop_replication) e [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication). Você pode fazer isso ao replicar entre duas instâncias do Amazon RDS para operações de longa duração, como a criação de índices grandes. Você também precisa interromper e iniciar a replicação ao importar ou exportar bancos de dados. Para obter mais informações, consulte [Importar dados para uma instância de banco de dados do Amazon RDS para MariaDB com tempo de inatividade reduzido](mariadb-importing-data-reduced-downtime.md) e [Exportar dados de uma instância de banco de dados MySQL usando replicação](MySQL.Procedural.Exporting.NonRDSRepl.md).
Se a replicação for interrompida por mais de 30 dias consecutivos, seja manualmente ou devido a um erro de replicação, o Amazon RDS a encerrará entre a instância de banco de dados de origem e todas as réplicas de leitura. Isso acontece para evitar um aumento nos requisitos de armazenamento da instância de banco de dados de origem e nos tempos de failover prolongado. A instância de banco de dados da réplica de leitura ainda está disponível. No entanto, a replicação não pode ser retomada porque os logs binários exigidos pela réplica de leitura são excluídos da instância de banco de dados de origem após o encerramento da replicação. Você pode criar uma nova réplica de leitura para a instância de banco de dados de origem a fim de restabelecer a replicação.
# Solução de problemas da réplica de leitura do MariaDB
As tecnologias de replicação do MariaDB são assíncronas. Como são assíncronas, são esperados ocasionais aumentos de `BinLogDiskUsage` na instância de banco de dados de origem e `ReplicaLag` na réplica de leitura. Por exemplo, um volume elevado de operações de gravação para a instância de banco de dados de origem pode ocorrer em paralelo. Por outro lado, as operações de gravação na réplica de leitura são serializadas usando um único thread de E/S, o que pode ocasionar um atraso entre a instância de origem e a réplica de leitura. Para obter mais informações sobre réplicas somente leitura na documentação do MariaDB, acesse [Visão geral da replicação](http://mariadb.com/kb/en/mariadb/replication-overview/).
Você pode fazer várias coisas para reduzir o atraso entre as atualizações de uma instância de banco de dados de origem e as atualizações subsequentes da réplica de leitura, como o seguinte:
+ Dimensionar uma réplica de leitura para ter um tamanho de armazenamento e uma categoria de instância de banco de dados comparáveis à da instância de banco de dados de origem.
+ Assegurar-se de que as configurações de parâmetros nos grupos de parâmetros de banco de dados utilizados pela instância de banco de dados de origem e pela réplica de leitura são compatíveis. Para mais informações e um exemplo, consulte a discussão sobre o parâmetro `max_allowed_packet` posteriormente nesta seção.
O Amazon RDS monitora o status de replicação de suas réplicas de leitura e atualiza o campo `Replication State` da instância da réplica de leitura para `Error` caso a replicação seja interrompida por qualquer motivo. Um exemplo pode ser se as consultas DML forem executadas no seu conflito de réplica de leitura com as atualizações feitas na instância de banco de dados de origem.
Você pode analisar os detalhes do erro associado gerado pelo mecanismo do MariaDB visualizando o campo `Replication Error`. Os eventos que indicam o status da réplica de leitura também são gerados, incluindo [RDS-EVENT-0045](USER_Events.Messages.md#RDS-EVENT-0045), [RDS-EVENT-0046](USER_Events.Messages.md#RDS-EVENT-0046) e [RDS-EVENT-0047](USER_Events.Messages.md#RDS-EVENT-0047). Para mais informações sobre eventos e como se inscrever neles, consulte [Trabalhar com a notificação de eventos do Amazon RDS](USER_Events.md). Se for retornada uma mensagem de erro do MariaDB, analise o erro na [documentação de mensagens de erro do MariaDB](http://mariadb.com/kb/en/mariadb/mariadb-error-codes/).
Um problema comum que pode causar erros de replicação é quando o valor do parâmetro `max_allowed_packet` para uma réplica de leitura é menor que o do parâmetro `max_allowed_packet` para a instância de banco de dados de origem. O parâmetro `max_allowed_packet` é um parâmetro personalizado que pode ser definido em um grupo de parâmetros de banco de dados usado para especificar o código de DML que pode ser executado no banco de dados. Em alguns casos, o valor do parâmetro `max_allowed_packet` no grupo de parâmetros de banco de dados associado a uma instância de banco de dados de origem é menor do que o valor do parâmetro `max_allowed_packet` no grupo de parâmetros de banco de dados associado à réplica de leitura da origem. Nesses casos, o processo de replicação pode exibir um erro (Packet bigger than 'max\$1allowed\$1packet' bytes [Pacote maior que a quantidade máxima de bytes]) e interromper a replicação. É possível corrigir o erro fazendo com que a origem e a réplica de leitura usem grupos de parâmetros de banco de dados com os mesmos valores do parâmetro `max_allowed_packet`.
Outras situações comuns que podem causar erros de replicação incluem o seguinte:
+ A gravação em tabelas em uma réplica de leitura. Se estiver criando índices em uma réplica de leitura, você precisará ter o parâmetro `read_only` definido como **0** para criar os índices. Se você estiver gravando em tabelas na réplica de leitura, isso poderá interromper a replicação.
+ O uso de um mecanismo de armazenamento não transacional, como MyISAM. As réplicas de leitura exigem um mecanismo de armazenamento transacional. A replicação só é compatível com o mecanismo de armazenamento InnoDB no MariaDB.
+ Usando consultas não deterministas inseguras, como `SYSDATE()`. Para obter mais informações, consulte [Determinação de instruções seguras e inseguras no registro de logs binários](https://dev.mysql.com/doc/refman/8.0/en/replication-rbr-safe-unsafe.html).
Se você acreditar que pode ignorar um erro com segurança, siga as etapas descritas em [Ignorar o erro de replicação atual para o RDS para MySQL](Appendix.MySQL.CommonDBATasks.SkipError.md). Caso contrário, você pode excluir a réplica de leitura e criar uma instância usando o mesmo identificador de instância de banco de dados para que o endpoint permaneça o mesmo que o da sua antiga réplica de leitura. Se um erro de replicação for corrigido, o `Replication State` mudará para *replicating*.
Para as instâncias de banco de dados do MariaDB, em alguns casos, as réplicas de leitura não poderão ser alternadas para a secundária se alguns eventos de log binário (binlog) não forem liberados durante a falha. Nesses casos, exclua e recrie manualmente as réplicas de leitura. Você pode reduzir a chance disso acontecer definindo os seguintes valores de parâmetro: `sync_binlog=1` e `innodb_flush_log_at_trx_commit=1`. Essas configurações podem reduzir a performance, portanto, teste o impacto delas antes de implantar as alterações em um ambiente de produção.
# Configurar a replicação baseada em GTID com uma instância de origem externa
Você pode configurar a replicação com base em identificadores de transação global (GTIDs) de uma instância externa do MariaDB da versão 10.0.24 ou posteriores em uma instância de banco de dados do MariaDB. Siga estas diretrizes ao configurar uma instância de origem externa e uma réplica no Amazon RDS:
+ Monitore eventos de failover da instância do banco de dados do RDS para MariaDB que é sua réplica. Se ocorrer um failover, a instância de banco de dados que for a sua réplica poderá ser recriada em um novo host com um endereço de rede diferente. Para obter informações sobre como monitorar eventos de failover, consulte [Trabalhar com a notificação de eventos do Amazon RDS](USER_Events.md).
+ Mantenha os logs binários (binlogs) em sua instância de origem até confirmar que foram aplicados à réplica. Essa manutenção garante que seja possível restaurar a instância de origem em caso de falha.
+ Ative backups automáticos em sua instância do banco de dados MariaDB no Amazon RDS. Ativar backups automáticos garante que seja possível restaurar sua réplica para um determinado ponto no tempo, caso precise ressincronizar sua instância de origem e sua réplica. Para obter informações sobre backups e restauração Point-In-Time, consulte [Backup, restauração e exportação de dados](CHAP_CommonTasks.BackupRestore.md).
**nota**
As permissões necessárias para iniciar a replicação em uma instância de banco de dados MariaDB são restritas e não estão disponíveis ao seu usuário mestre do Amazon RDS. Devido a isso, você deve usar os comandos [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md) e [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) do Amazon RDS para configurar a replicação entre seu banco de dados em e o seu banco de dados do RDS para MariaDB.
Para iniciar a replicação entre uma instância de origem externa e uma instância de banco de dados MariaDB no Amazon RDS, use o seguinte procedimento.
**Como iniciar a replicação**
1. Confirme que a instância de origem MariaDB é somente leitura:
```
mysql> FLUSH TABLES WITH READ LOCK;
mysql> SET GLOBAL read_only = ON;
```
1. Obtenha o GTID atual da instância externa do MariaDB. Você pode fazer isso usando `mysql` ou o editor de consulta de sua preferência para executar `SELECT @@gtid_current_pos;`.
O GTID é formatado como `--`. Um GTID típico é parecido com **0-1234510749-1728**. Para obter mais informações sobre GTIDs e suas partes de componentes, consulte [ID de transação global](http://mariadb.com/kb/en/mariadb/global-transaction-id/) na documentação do MariaDB.
1. Copie o banco de dados da instância do MariaDB externa para a instância do banco de dados MariaDB usando `mysqldump`. Para bancos de dados muito grandes, convém usar o procedimento em [Importar dados para uma instância de banco de dados do Amazon RDS para MariaDB com tempo de inatividade reduzido](mariadb-importing-data-reduced-downtime.md).
Para Linux, macOS ou Unix:
```
mysqldump \
--databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u local_user \
-plocal_password | mysql \
--host=hostname \
--port=3306 \
-u RDS_user_name \
-pRDS_password
```
Para Windows:
```
mysqldump ^
--databases database_name ^
--single-transaction ^
--compress ^
--order-by-primary \
-u local_user \
-plocal_password | mysql ^
--host=hostname ^
--port=3306 ^
-u RDS_user_name ^
-pRDS_password
```
**nota**
Confirme que não há um espaço entre a opção `-p` e a senha inserida.
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
Use as opções `--host`, `--user (-u)`, `--port` e `-p` no comando `mysql` para especificar o nome do host, o nome do usuário, a porta e a senha para se conectar a sua instância de banco de dados MariaDB. O nome do host é o nome de DNS do endpoint da instância de banco de dados MariaDB, por exemplo, `myinstance.123456789012.us-east-1.rds.amazonaws.com`. Você pode encontrar o valor do endpoint nos detalhes da instância no Console de gerenciamento do Amazon RDS.
1. Confirme que é possível gravar na instância do MariaDB novamente.
```
mysql> SET GLOBAL read_only = OFF;
mysql> UNLOCK TABLES;
```
1. No console de gerenciamento do Amazon RDS, adicione o endereço IP do servidor, que hospeda o banco de dados MariaDB externo, ao grupo de segurança da VPC para a instância de banco de dados MariaDB. Para obter mais informações sobre como modificar um grupo de segurança da VPC, acesse [Grupos de segurança para a VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) no *Guia do usuário da Amazon Virtual Private Cloud*.
O endereço IP poderá ser alterado se as seguintes condições forem atendidas:
+ Se você estiver usando um endereço IP público para a comunicação entre a instância de origem externa e a instância de banco de dados.
+ A instância de origem externa foi interrompida e reiniciada.
Se essas condições forem atendidas, verifique o endereço IP antes de adicioná-lo.
Talvez também seja necessário configurar sua rede local para permitir conexões com o endereço IP de sua instância de banco de dados MariaDB, para que ela possa se comunicar com sua instância externa do MariaDB. Para encontrar o endereço IP da instância de banco de dados MariaDB, use o comando `host`.
```
host db_instance_endpoint
```
O nome do host é o nome de DNS do endpoint da instância de banco de dados MariaDB.
1. Usando o cliente de sua preferência, conecte-se à instância MariaDB externa e crie um usuário do MariaDB a ser usado para a replicação. Esta conta é usada unicamente para replicação e deve estar restrita ao seu domínio para melhorar a segurança. Veja um exemplo a seguir.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**nota**
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
1. Para a instância externa do MariaDB, conceda privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` para seu usuário de replicação. Por exemplo, para conceder os privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` em todos os bancos de dados para o usuário '`repl_user`' de seu domínio, emita o seguinte comando.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
1. Torne uma réplica a instância de banco de dados MariaDB. Conecte-se à instância de banco de dados MariaDB como o usuário mestre e identifique o banco de dados MariaDB externo como a instância de origem de replicação usando o comando [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md). Use o GTID que você determinou na etapa 2. Veja um exemplo a seguir.
```
CALL mysql.rds_set_external_master_gtid ('mymasterserver.mydomain.com', 3306, 'repl_user', 'password', 'GTID', 1);
```
**nota**
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
1. Na instância de banco de dados MariaDB, emita o comando [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication), para iniciar a replicação:
```
CALL mysql.rds_start_replication;
```
# Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa
É possível configurar a replicação entre uma instância de banco de dados do RDS para MySQL ou do MariaDB e uma instância do MySQL ou do MariaDB externa ao Amazon RDS usando a replicação de arquivos de log binários.
**Topics**
+ [Antes de começar](#MySQL.Procedural.Importing.External.Repl.BeforeYouBegin)
+ [Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa](#MySQL.Procedural.Importing.External.Repl.Procedure)
## Antes de começar
Você pode configurar a replicação usando a posição do arquivo de log binário de transações replicadas.
As permissões necessárias para iniciar a replicação em uma instância de banco de dados do Amazon RDS são restritas e não estão disponíveis ao seu usuário mestre do Amazon RDS. Por isso, use os comandos [mysql.rds\$1set\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master) ou [mysql.rds\$1set\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) e [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) do Amazon RDS para configurar a replicação entre seu banco de dados on-line e seu banco de dados do Amazon RDS.
Para definir o formato de registro em log binário para um banco de dados MySQL e MariaDB, atualize o parâmetro `binlog_format`. Se a instância de banco de dados usar o grupo de parâmetros da instância de banco de dados padrão, crie um novo grupo de parâmetros de banco de dados para modificar o parâmetro `binlog_format`. No MariaDB e no MySQL 8.0 e versões anteriores, `binlog_format` tem como padrão `MIXED`. No entanto, você também pode definir o `binlog_format` como `ROW` ou `STATEMENT` se precisar de um formato específico de log binário (binlog). Reinicie a instância de banco de dados para que a alteração entre em vigor. No MySQL 8.4 e versões superiores, `binlog_format` tem como padrão `ROW`.
Para obter informações sobre como definir o parâmetro `binlog_format`, consulte [Configurar o registro em log binário do RDS para MySQL para bancos de dados single-AZ](USER_LogAccess.MySQL.BinaryFormat.md). Para obter informações sobre as implicações de tipos de replicação do MySQL diferentes, consulte [Vantagens e desvantagens da replicação baseada em instrução e baseada em linha](https://dev.mysql.com/doc/refman/8.0/en/replication-sbr-rbr.html) na documentação do MySQL.
## Configurar a replicação da posição do arquivo de log binário com uma instância de origem externa
Siga estas diretrizes ao configurar uma instância de origem externa e uma réplica no Amazon RDS:
+ Monitore eventos de failover para a instância do banco de dados do Amazon RDS, que é sua réplica. Se ocorrer um failover, a instância de banco de dados que for a sua réplica poderá ser recriada em um novo host com um endereço de rede diferente. Para obter informações sobre como monitorar eventos de failover, consulte [Trabalhar com a notificação de eventos do Amazon RDS](USER_Events.md).
+ Retenha os logs binários na instância de origem até confirmar que eles foram aplicados à réplica. Esta manutenção garante que seja possível restaurar sua instância de origem em caso de falha.
+ Ative backups automatizados na sua instância de banco de dados do Amazon RDS. Ativar backups automáticos garante que seja possível restaurar sua réplica para um determinado ponto no tempo, caso seja necessário ressincronizar sua instância de origem e sua réplica. Para obter informações sobre backups e restauração Point-In-Time, consulte [Backup, restauração e exportação de dados](CHAP_CommonTasks.BackupRestore.md).
**Como configurar a replicação do arquivo de log binário com uma instância de origem externa**
1. Torne a instância de origem MySQL ou MariaDB somente leitura.
```
mysql> FLUSH TABLES WITH READ LOCK;
mysql> SET GLOBAL read_only = ON;
```
1. Execute o comando `SHOW MASTER STATUS` na instância do MySQL ou MariaDB de origem para determinar a localização do log binário.
Você recebe um resultado semelhante ao seguinte exemplo.
```
File Position
------------------------------------
mysql-bin-changelog.000031 107
------------------------------------
```
1. Copie o banco de dados da instância externa para a instância de banco de dados do Amazon RDS usando `mysqldump`. Para bancos de dados muito grandes, convém usar o procedimento em [Importar dados para um banco de dados do Amazon RDS para MySQL com tempo de inatividade reduzido](mysql-importing-data-reduced-downtime.md).
Para Linux, macOS ou Unix:
```
mysqldump --databases database_name \
--single-transaction \
--compress \
--order-by-primary \
-u local_user \
-plocal_password | mysql \
--host=hostname \
--port=3306 \
-u RDS_user_name \
-pRDS_password
```
Para Windows:
```
mysqldump --databases database_name ^
--single-transaction ^
--compress ^
--order-by-primary ^
-u local_user ^
-plocal_password | mysql ^
--host=hostname ^
--port=3306 ^
-u RDS_user_name ^
-pRDS_password
```
**nota**
Confirme que não há um espaço entre a opção `-p` e a senha inserida.
Para especificar o nome do host, o nome do usuário, a porta e a senha para se conectar à instância de banco de dados Amazon RDS, use as opções `--host`, `--user (-u)`, `--port` e `-p` no comando `mysql`. O nome do host é o nome do Serviço de Nome de Domínio (DNS) do endpoint da instância de banco de dados do Amazon RDS, por exemplo, `myinstance.123456789012.us-east-1.rds.amazonaws.com`. Você pode encontrar o valor do endpoint nos detalhes da instância no Console de gerenciamento da AWS.
1. Torne a instância MySQL ou MariaDB de origem novamente gravável.
```
mysql> SET GLOBAL read_only = OFF;
mysql> UNLOCK TABLES;
```
Para obter mais informações sobre como fazer backups para usar com a replicação, consulte a [documentação do MySQL](https://dev.mysql.com/doc/refman/8.0/en/replication-solutions-backups-read-only.html).
1. No Console de gerenciamento da AWS, adicione o endereço IP do servidor que hospeda o banco de dados externo ao grupo de segurança da nuvem privada virtual (VPC) para a instância de banco de dados Amazon RDS. Para obter mais informações sobre como modificar um grupo de segurança da VPC, consulte [Grupos de segurança para a VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_SecurityGroups.html) no *Guia do usuário da Amazon Virtual Private Cloud*.
O endereço IP poderá ser alterado se as seguintes condições forem atendidas:
+ Se você estiver usando um endereço IP público para a comunicação entre a instância de origem externa e a instância de banco de dados.
+ A instância de origem externa foi interrompida e reiniciada.
Se essas condições forem atendidas, verifique o endereço IP antes de adicioná-lo.
Você também pode precisar configurar a rede local para permitir conexões com o endereço IP da instância de banco de dados do Amazon RDS. Isso é realizado para que a rede local consiga se comunicar com a instância do MySQL ou do MariaDB externa. Para localizar o endereço IP da instância de banco de dados do Amazon RDS, use o comando `host`.
```
host db_instance_endpoint
```
O nome do host é o nome de DNS do endpoint da instância de banco de dados do Amazon RDS.
1. Usando o cliente de sua preferência, conecte-se à instância externa e crie um usuário a ser usado para a replicação. Use essa conta unicamente para replicação e restrinja-a ao seu domínio para melhorar a segurança. Veja um exemplo a seguir.
```
CREATE USER 'repl_user'@'mydomain.com' IDENTIFIED BY 'password';
```
**nota**
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança.
1. Para a instância externa, conceda os privilégios `REPLICATION CLIENT` e `REPLICATION SLAVE` para seu usuário de replicação. Por exemplo, para conceder os privilégios de `REPLICATION CLIENT` e `REPLICATION SLAVE` em todos os bancos de dados para o usuário '`repl_user`' de seu domínio, emita o seguinte comando.
```
GRANT REPLICATION CLIENT, REPLICATION SLAVE ON *.* TO 'repl_user'@'mydomain.com';
```
1. Transforma a instância de banco de dados do Amazon RDS na réplica. Para fazer isso, primeiro se conecte à instância de banco de dados do Amazon RDS como usuário mestre. Depois disso, identifique o banco de dados MySQL ou MariaDB externo como a instância de origem usando o comando [mysql.rds\$1set\$1external\$1source (RDS para MySQL versões principais 8.4 e posteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source) ou [mysql.rds\$1set\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master). Use o nome do arquivo de log mestre e a posição do log mestre que você determinou na etapa 2. Os comandos a seguir são exemplos.
**MySQL 8.4**
```
CALL mysql.rds_set_external_source ('mysourceserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**MariaDB e MySQL 8.0 e 5.7**
```
CALL mysql.rds_set_external_master ('mymasterserver.mydomain.com', 3306, 'repl_user', 'password', 'mysql-bin-changelog.000031', 107, 1);
```
**nota**
No RDS para MySQL, é possível optar por usar a replicação atrasada executando o procedimento armazenado [mysql.rds\$1set\$1external\$1source\$1with\$1delay (RDS para MySQL versões principais 8.4 e superiores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_source_with_delay) ou [mysql.rds\$1set\$1external\$1master\$1with\$1delay (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master_with_delay). No RDS para MySQL, um motivo para usar a replicação atrasada é ativar a recuperação de desastres com o procedimento armazenado [mysql.rds\$1start\$1replication\$1until](mysql-stored-proc-replicating.md#mysql_rds_start_replication_until). Atualmente, o RDS para MariaDB é compatível com a replicação atrasada, mas não com o procedimento `mysql.rds_start_replication_until`.
1. Na instância de banco de dados do Amazon RDS, emita o comando [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) para iniciar a replicação.
```
CALL mysql.rds_start_replication;
```
# Opções para o mecanismo de banco de dados do MariaDB
A seguir, você encontrará uma descrição das opções, ou recursos adicionais, que estão disponíveis para instâncias do Amazon RDS que executam o mecanismo de banco de dados do MariaDB. Para ativar essas opções, adicione-as a um grupo de opções personalizado e, depois, associe o grupo de opções à sua instância de banco de dados. Para ter mais informações sobre como trabalhar com grupos de opções, consulte [Trabalhar com grupos de opções](USER_WorkingWithOptionGroups.md).
O Amazon RDS oferece suporte às seguintes opções do MariaDB:
| ID da opção | Versões do mecanismo |
| --- | --- |
| `MARIADB_AUDIT_PLUGIN` | MariaDB 10.3 e posterior |
## Suporte ao plugin de auditoria do MariaDB
O Amazon RDS oferece suporte ao MariaDB Audit Plugin nas instâncias do banco de dados do MariaDB. O MariaDB Audit Plugin registra a atividade do banco de dados, como usuários que fazem logon no banco de dados, as consultas são executadas contra o banco de dados e muito mais. O registro da atividade do banco de dados é armazenado em um arquivo de log.
### Definições de opções do plugin de auditoria
O Amazon RDS oferece suporte para as seguintes configurações para a opção MariaDB Audit Plugin.
**nota**
Se você não definir uma configuração de opção no console do RDS, o RDS usará a configuração padrão.
| Configuração da opção | Valores válidos | Valor padrão | Descrição |
| --- | --- | --- | --- |
| `SERVER_AUDIT_FILE_PATH` | `/rdsdbdata/log/audit/` | `/rdsdbdata/log/audit/` | A localização dos arquivos de log. O arquivo de log contém o registro de atividades especificadas em `SERVER_AUDIT_EVENTS`. Para ter mais informações, consulte [Como visualizar e listar arquivos de log do banco de dados](USER_LogAccess.Procedural.Viewing.md) e [Arquivos de log do banco de dados MariaDB](USER_LogAccess.Concepts.MariaDB.md). |
| `SERVER_AUDIT_FILE_ROTATE_SIZE` | 1–1000000000 | 1000000 | O tamanho em bytes que, quando alcançado, faz com que o arquivo rotacione. Para ter mais informações, consulte [Alternância e retenção de logs para o MariaDB](USER_LogAccess.MariaDB.LogFileSize.md). |
| `SERVER_AUDIT_FILE_ROTATIONS` | 0–100 | 9 | O número de rotações de log para salvar quando `server_audit_output_type=file`. Se definido como 0, o arquivo de log nunca é alternado. Para ter mais informações, consulte [Alternância e retenção de logs para o MariaDB](USER_LogAccess.MariaDB.LogFileSize.md) e [Como baixar um arquivo de log de banco de dados](USER_LogAccess.Procedural.Downloading.md). |
| `SERVER_AUDIT_EVENTS` | `CONNECT`, `QUERY`, `TABLE`, `QUERY_DDL`, `QUERY_DML`, `QUERY_DML_NO_SELECT`, `QUERY_DCL` | `CONNECT`, `QUERY` | Os tipos de atividades a serem gravados no log. A instalação do MariaDB Audit Plugin é registrada em log. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/Appendix.MariaDB.Options.html) |
| `SERVER_AUDIT_INCL_USERS` | Vários valores separados por vírgulas | Nenhum | Inclua apenas atividades dos usuários especificados. Por padrão, a atividade é registrada para todos os usuários. `SERVER_AUDIT_INCL_USERS` e `SERVER_AUDIT_EXCL_USERS` são mutuamente exclusivos. Se você adicionar valores ao `SERVER_AUDIT_INCL_USERS`, certifique-se de que nenhum valor seja adicionado ao `SERVER_AUDIT_EXCL_USERS`. |
| `SERVER_AUDIT_EXCL_USERS` | Vários valores separados por vírgulas | Nenhum | Exclua a atividade dos usuários especificados. Por padrão, a atividade é registrada para todos os usuários. `SERVER_AUDIT_INCL_USERS` e `SERVER_AUDIT_EXCL_USERS` são mutuamente exclusivos. Se você adicionar valores ao `SERVER_AUDIT_EXCL_USERS`, certifique-se de que nenhum valor seja adicionado ao `SERVER_AUDIT_INCL_USERS`. O usuário `rdsadmin` consulta o banco de dados a cada segundo para verificar a integridade do banco de dados. Dependendo das suas outras configurações, essa atividade pode fazer com que o tamanho do seu arquivo de log cresça muito rapidamente. Se você não precisa registrar essa atividade, adicione o usuário `rdsadmin` à lista `SERVER_AUDIT_EXCL_USERS`. `CONNECT`A atividade é sempre registrada para todos os usuários, mesmo se o usuário é especificado para essa configuração de opção. |
| `SERVER_AUDIT_LOGGING` | `ON` | `ON` | O registro em log está ativo. O único valor válido é `ON`. O Amazon RDS não oferece suporte à desativação do registro em log. Se quiser desativar o registro log, remova o MariaDB Audit Plugin. Para ter mais informações, consulte [Remover o MariaDB Audit Plugin](#Appendix.MariaDB.Options.AuditPlugin.Remove). |
| `SERVER_AUDIT_QUERY_LOG_LIMIT` | 0–2147483647 | 1024 | O limite do tamanho da string de consulta em um registro. |
### Adicionar o MariaDB Audit Plugin
O processo geral para adicionar o MariaDB Audit Plugin a uma instância de banco de dados é o seguinte:
1. Crie um novo grupo de opções, ou copie ou modifique um existente.
1. Adicione a opção ao grupo de opções.
1. Associe o grupo de opções à instância de banco de dados.
Depois de adicionar o MariaDB Audit Plugin, você não precisará reiniciar sua instância de banco de dados. Assim que o grupo de opções estiver ativo, a auditoria começará imediatamente.
**Para adicionar o MariaDB Audit Plugin**
1. Determine o grupo de opções que você deseja usar. Você pode criar um novo grupo de opções ou usar um existente. Se você quiser usar um grupo de opções existente, vá para a próxima etapa. Caso contrário, crie um grupo de opções de banco de dados personalizado. Escolha **mariadb** em **Engine** (Mecanismo) e escolha **10.3** ou posteriores para **Major engine version** (Versão principal do mecanismo). Para ter mais informações, consulte [Criar um grupo de opções](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.Create).
1. Adicione a opção **MARIADB\$1AUDIT\$1PLUGIN** ao grupo de opções e defina as configurações da opção. Para ter mais informações sobre a adição de opções, consulte [Adicionar uma opção a um grupo de opções](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.AddOption). Para ter mais informações sobre cada configuração, consulte [Definições de opções do plugin de auditoria](#Appendix.MariaDB.Options.AuditPlugin.Options).
1. Aplique o grupo de opções a uma instância de banco de dados nova ou existente.
+ Para uma nova instância de banco de dados, você aplica o grupo de opções ao executar a instância. Para ter mais informações, consulte [Criar uma instância de banco de dados do Amazon RDS](USER_CreateDBInstance.md).
+ Para uma instância de banco de dados existente, aplique o grupo de opções modificando a instância de banco de dados e anexando o novo grupo de opções. Para ter mais informações, consulte [Modificar uma instância de banco de dados do Amazon RDS](Overview.DBInstance.Modifying.md).
### Visualizar e baixar o log do plugin de auditoria do MariaDB
Depois de habilitar o MariaDB Audit Plugin, você acessará os resultados nos arquivos de log da mesma forma que você acessa outros arquivos de log baseados em texto. Os arquivos de log de auditoria estão localizados em `/rdsdbdata/log/audit/`. Para obter informações sobre como visualizar o arquivo de log no console, consulte [Como visualizar e listar arquivos de log do banco de dados](USER_LogAccess.Procedural.Viewing.md). Para obter informações sobre como baixar o arquivo de log, consulte [Como baixar um arquivo de log de banco de dados](USER_LogAccess.Procedural.Downloading.md).
### Modificar as configurações do plugin de auditoria do MariaDB
Após habilitar o MariaDB Audit Plugin, você pode modificar as configurações do plugin. Para ter mais informações sobre como modificar as configurações da opção, consulte [Modificar uma configuração de opção](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.ModifyOption). Para ter mais informações sobre cada configuração, consulte [Definições de opções do plugin de auditoria](#Appendix.MariaDB.Options.AuditPlugin.Options).
### Remover o MariaDB Audit Plugin
O Amazon RDS não oferece suporte à desativação do registro em log no MariaDB Audit Plugin. No entanto, você pode remover o plugin de uma instância de banco de dados. Quando você remove o MariaDB Audit Plugin, a instância de banco de dados é reiniciada automaticamente para interromper a auditoria.
Para remover o MariaDB Audit Plugin de uma instância de banco de dados, siga um destes procedimentos:
+ Remova a opção MariaDB Audit Plugin do grupo de opções ao qual ela pertence. Essa alteração afeta todas as instâncias de bancos de dados que usam o grupo de opções. Para ter mais informações, consulte [Remover uma opção de um grupo de opções](USER_WorkingWithOptionGroups.md#USER_WorkingWithOptionGroups.RemoveOption)
+ Modifique a instância de banco de dados e especifique um grupo de opções diferente que não inclua o plugin. Essa alteração afeta uma única instância de banco de dados. Você pode especificar um grupo de opções padrão (vazio) ou criar um grupo de opções personalizado diferente. Para ter mais informações, consulte [Modificar uma instância de banco de dados do Amazon RDS](Overview.DBInstance.Modifying.md).
# Parâmetros para MariaDB
Por padrão, uma instância de banco de dados MariaDB usa um grupo de parâmetros de banco de dados específico para um banco de dados MariaDB. Esse grupo de parâmetros contém alguns mas não todos os parâmetros contidos nos grupos de parâmetros de banco de dados do Amazon RDS para o mecanismo de banco de dados MySQL. Ele também contém alguns parâmetros novos específicos do MariaDB. Para obter informações sobre como trabalhar com grupos de parâmetros e definir parâmetros, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
## Visualizar parâmetros do MariaDB
Os parâmetros do RDS for MariaDB são definidos com os valores padrão do mecanismo de armazenamento que você selecionou. Para obter mais informações sobre os parâmetros do MariaDB, consulte a [documentação do MariaDB](http://mariadb.com/kb/en/mariadb/documentation/). Para obter mais informações sobre os mecanismos de armazenamento do MariaDB, consulte [Mecanismos de armazenamento compatíveis com MariaDB no Amazon RDS](MariaDB.Concepts.Storage.md).
Você pode exibir os parâmetros disponíveis para uma versão específica do RDS for MariaDB usando o console do RDS ou a AWS CLI. Para obter informações sobre como visualizar os parâmetros em um grupo de parâmetros do MariaDB no console do RDS, consulte [Visualizar valores de parâmetros para um grupo de parâmetros de banco de dados no Amazon RDS](USER_WorkingWithParamGroups.Viewing.md).
Usando a AWS CLI, você pode visualizar os parâmetros de uma versão do RDS for MariaDB executando o comando [https://docs.aws.amazon.com/cli/latest/reference/rds/describe-engine-default-parameters.html](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-engine-default-parameters.html). Especifique um destes valores a seguir para a opção `--db-parameter-group-family`:
+ `mariadb11.8`
+ `mariadb11.4`
+ `mariadb10.11`
+ `mariadb10.6`
+ `mariadb10.5`
+ `mariadb10.4`
+ `mariadb10.3`
Por exemplo, para visualizar parâmetros do RDS for MariaDB, versão 10.6, execute o comando a seguir.
```
aws rds describe-engine-default-parameters --db-parameter-group-family mariadb10.6
```
O resultado será semelhante ao mostrado a seguir.
```
{
"EngineDefaults": {
"Parameters": [
{
"ParameterName": "alter_algorithm",
"Description": "Specify the alter table algorithm.",
"Source": "engine-default",
"ApplyType": "dynamic",
"DataType": "string",
"AllowedValues": "DEFAULT,COPY,INPLACE,NOCOPY,INSTANT",
"IsModifiable": true
},
{
"ParameterName": "analyze_sample_percentage",
"Description": "Percentage of rows from the table ANALYZE TABLE will sample to collect table statistics.",
"Source": "engine-default",
"ApplyType": "dynamic",
"DataType": "float",
"AllowedValues": "0-100",
"IsModifiable": true
},
{
"ParameterName": "aria_block_size",
"Description": "Block size to be used for Aria index pages.",
"Source": "engine-default",
"ApplyType": "static",
"DataType": "integer",
"AllowedValues": "1024-32768",
"IsModifiable": false
},
{
"ParameterName": "aria_checkpoint_interval",
"Description": "Interval in seconds between automatic checkpoints.",
"Source": "engine-default",
"ApplyType": "dynamic",
"DataType": "integer",
"AllowedValues": "0-4294967295",
"IsModifiable": true
},
...
```
Para listar somente os parâmetros modificáveis do RDS for MariaDB versão 10.6, execute o comando a seguir.
Para Linux, macOS ou Unix:
```
aws rds describe-engine-default-parameters --db-parameter-group-family mariadb10.6 \
--query 'EngineDefaults.Parameters[?IsModifiable==`true`]'
```
Para Windows:
```
aws rds describe-engine-default-parameters --db-parameter-group-family mariadb10.6 ^
--query "EngineDefaults.Parameters[?IsModifiable==`true`]"
```
## Parâmetros do MySQL que não estão disponíveis
Os parâmetros MySQL a seguir não estão disponíveis nos parameter groups de banco de dados específicos do MariaDB:
+ bind\$1address
+ binlog\$1error\$1action
+ binlog\$1gtid\$1simple\$1recovery
+ binlog\$1max\$1flush\$1queue\$1time
+ binlog\$1order\$1commits
+ binlog\$1row\$1image
+ binlog\$1rows\$1query\$1log\$1events
+ binlogging\$1impossible\$1mode
+ block\$1encryption\$1mode
+ core\$1file
+ default\$1tmp\$1storage\$1engine
+ div\$1precision\$1increment
+ end\$1markers\$1in\$1json
+ enforce\$1gtid\$1consistency
+ eq\$1range\$1index\$1dive\$1limit
+ explicit\$1defaults\$1for\$1timestamp
+ gtid\$1executed
+ gtid-mode
+ gtid\$1next
+ gtid\$1owned
+ gtid\$1purged
+ log\$1bin\$1basename
+ log\$1bin\$1index
+ log\$1bin\$1use\$1v1\$1row\$1events
+ log\$1slow\$1admin\$1statements
+ log\$1slow\$1slave\$1statements
+ log\$1throttle\$1queries\$1not\$1using\$1indexes
+ master-info-repository
+ optimizer\$1trace
+ optimizer\$1trace\$1features
+ optimizer\$1trace\$1limit
+ optimizer\$1trace\$1max\$1mem\$1size
+ optimizer\$1trace\$1offset
+ relay\$1log\$1info\$1repository
+ rpl\$1stop\$1slave\$1timeout
+ slave\$1parallel\$1workers
+ slave\$1pending\$1jobs\$1size\$1max
+ slave\$1rows\$1search\$1algorithms
+ storage\$1engine
+ table\$1open\$1cache\$1instances
+ timed\$1mutexes
+ transaction\$1allow\$1batching
+ validate-password
+ validate\$1password\$1dictionary\$1file
+ validate\$1password\$1length
+ validate\$1password\$1mixed\$1case\$1count
+ validate\$1password\$1number\$1count
+ validate\$1password\$1policy
+ validate\$1password\$1special\$1char\$1count
Para obter mais informações sobre os parâmetros do MySQL, consulte a [documentação do MySQL](https://dev.mysql.com/doc/refman/8.0/en/).
# Migrar dados de um snapshot de banco de dados do MySQL para uma instância de banco de dados do MariaDB
É possível migrar um snapshot de banco de dados do RDS para MySQL para uma nova instância de banco de dados que executa o MariaDB utilizando o Console de gerenciamento da AWS, a AWS CLI ou a API do Amazon RDS. É necessário usar um snapshot de banco de dados criado em uma instância de banco de dados do Amazon RDS executando o MySQL 5.6 ou 5.7. Para saber como criar um snapshot de banco de dados do RDS para MySQL, consulte [Criar um snapshot de banco de dados para uma instância de banco de dados single-AZ para o Amazon RDS](USER_CreateSnapshot.md).
A migração do snapshot não afeta a instância de banco de dados original da qual o snapshot foi tirado. Você pode testar e validar a nova instância de banco de dados antes de desviar o tráfego para ela como um substituto para a instância de banco de dados original.
Após a migração do MySQL para o MariaDB, a instância de banco de dados do MariaDB será associada ao grupo de parâmetros de banco de dados e ao grupo de opções. Depois de restaurar o snapshot de banco de dados, você poderá associar um grupo de parâmetros de banco de dados personalizado à nova instância de banco de dados. No entanto, um grupo de parâmetros do MariaDB apresenta um conjunto diferente de variáveis de sistema configuráveis. Para obter informações sobre as diferenças entre as variáveis de sistema do MySQL e do MariaDB, consulte [Diferenças em variáveis de sistema entre o MariaDB e o MySQL](https://mariadb.com/kb/en/system-variable-differences-between-mariadb-and-mysql/). Para saber mais sobre grupos de parâmetros de banco de dados, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md). Para saber mais sobre option groups, consulte [Trabalhar com grupos de opções](USER_WorkingWithOptionGroups.md).
## Executar a migração
Você pode migrar um snapshot de banco de dados do RDS para MySQL para uma nova instância de banco de dados MariaDB usando o Console de gerenciamento da AWS, a AWS CLI ou a API do RDS.
### Console
**Para migrar um snapshot de banco de dados do MySQL para uma instância de banco de dados do MariaDB**
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon RDS em [https://console.aws.amazon.com/rds/](https://console.aws.amazon.com/rds/).
1. No painel de navegação, selecione **Snapshots** e, em seguida, selecione o snapshot de banco de dados MySQL que você deseja migrar.
1. Em **Actions** (Ações), escolha **Migrate snapshot** (Migrar snapshot). A página **Migrate Database** (Migrar banco de dados) é exibida.
1. Em **Migrate to DB Engine (Migrar para o mecanismo de banco de dados)**, selecione **mariadb**.
O Amazon RDS seleciona uma opção para **DB engine version** (Versão do mecanismo de banco de dados) automaticamente. Não é possível alterar a versão do mecanismo de banco de dados.
![\[A página Migrar banco de dados para migrar do MySQL para o MariaDB no console do Amazon RDS.\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/UserGuide/images/MigrateMariaDB.png)
1. Nas seções restantes, especifique suas configurações de instância de banco de dados. Para obter informações sobre cada configuração, consulte [Configurações para instâncias de banco de dados](USER_CreateDBInstance.Settings.md).
1. Escolha **Migrate (Migrar)**.
### AWS CLI
Para migrar dados de um snapshot de banco de dados do MySQL para uma instância de banco de dados MariaDB, use o comando [https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html](https://docs.aws.amazon.com/cli/latest/reference/rds/restore-db-instance-from-db-snapshot.html) da AWS CLI com as seguintes opções:
+ --db-instance-identifier – Nome da instância de banco de dados para criar a partir do snapshot de banco de dados.
+ --db-snapshot-identifier – O identificador para restaurar o snapshot de banco de dados.
+ --engine – O mecanismo de banco de dados a utilizar na nova instância.
**Example**
Para Linux, macOS ou Unix:
```
1. aws rds restore-db-instance-from-db-snapshot \
2. --db-instance-identifier newmariadbinstance \
3. --db-snapshot-identifier mysqlsnapshot \
4. --engine mariadb
```
Para Windows:
```
1. aws rds restore-db-instance-from-db-snapshot ^
2. --db-instance-identifier newmariadbinstance ^
3. --db-snapshot-identifier mysqlsnapshot ^
4. --engine mariadb
```
### API
Para migrar dados de um snapshot de banco de dados do MySQL para uma instância de banco de dados do MariaDB, chame a operação [https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_RestoreDBInstanceFromDBSnapshot.html) da API do Amazon RDS.
## Incompatibilidades entre o MariaDB e o MySQL
As incompatibilidades entre o MySQL e o MariaDB incluem o seguinte:
+ Não é possível migrar um snapshot de banco de dados criado com o MySQL 8.0 para o MariaDB.
+ Se o banco de dados MySQL usa um hash de senha SHA256, certifique-se de redefinir senhas de usuário com hash SHA256 antes de se conectar ao banco de dados MariaDB. O código a seguir mostra como redefinir uma senha com hash SHA256.
```
SET old_passwords = 0;
UPDATE mysql.user SET plugin = 'mysql_native_password',
Password = PASSWORD('new_password')
WHERE (User, Host) = ('master_user_name', %);
FLUSH PRIVILEGES;
```
+ Se a sua conta de usuário primária do RDS utilizar o hash de senha SHA-256, redefina a senha utilizando o Console de gerenciamento da AWS, o comando [https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html](https://docs.aws.amazon.com/cli/latest/reference/rds/modify-db-instance.html) da AWS CLI ou a operação [ModifyDBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_ModifyDBInstance.html) da API do RDS. Para ter mais informações sobre como modificar uma instância de banco de dados , consulte [Modificar uma instância de banco de dados do Amazon RDS](Overview.DBInstance.Modifying.md).
+ O MariaDB não é compatível com o plugin Memcached. No entanto, os dados usados pelo plugin Memcached são armazenados como tabelas do InnoDB. Após migrar um snapshot de banco de dados do MySQL, você poderá acessar os dados usados pelo plugin Memcached usando o SQL. Para mais informações sobre o banco de dados innodb\$1memcache, consulte [Elementos internos do plugin memcached do InnoDB](https://dev.mysql.com/doc/refman/8.0/en/innodb-memcached-internals.html).
# Referência do MariaDB no SQL do Amazon RDS
A seguir, há descrições de procedimentos armazenados em sistema que estão disponíveis para instâncias do Amazon RDS em execução no mecanismo de banco de dados do MariaDB.
Também é possível usar os procedimentos armazenados em sistema que estão disponíveis para as instâncias de banco de dados MySQL para instâncias de banco de dados MariaDB. Esses procedimentos armazenados estão documentados em [Referência de procedimentos armazenados do RDS para MySQL](Appendix.MySQL.SQLRef.md). As instâncias de banco de dados MariaDB são compatíveis com todos os procedimentos armazenados, exceto `mysql.rds_start_replication_until` e `mysql.rds_start_replication_until_gtid`.
Além disso, os procedimentos armazenados em sistema a seguir são compatíveis apenas para instâncias de banco de dados do Amazon RDS que executam o MariaDB:
+ [mysql.rds\$1replica\$1status](mysql_rds_replica_status.md)
+ [mysql.rds\$1set\$1external\$1master\$1gtid](mysql_rds_set_external_master_gtid.md)
+ [mysql.rds\$1kill\$1query\$1id](mysql_rds_kill_query_id.md)
+ [mysql.rds\$1execute\$1operation](mysql_rds_execute_operation.md)
# mysql.rds\$1replica\$1status
Mostra o status de replicação de uma réplica de leitura MariaDB.
Chame este procedimento na réplica de leitura para mostrar informações de status sobre parâmetros essenciais dos threads de réplica.
## Sintaxe
```
CALL mysql.rds_replica_status;
```
## Observações de uso
Esse procedimento só é compatível com instâncias de banco de dados MariaDB que executam MariaDB versão 10.5 e versões posteriores.
Esse procedimento é o equivalente ao comando `SHOW REPLICA STATUS`. Esse comando não é compatível com instâncias de banco de dados MariaDB versão 10.5 e posterior.
Nas versões anteriores do MariaDB, esse comando `SHOW SLAVE STATUS` exigia o privilégio `REPLICATION SLAVE`. No MariaDB versão 10.5 e posteriores, ele requer o privilégio `REPLICATION REPLICA ADMIN`. Para proteger o gerenciamento do RDS das instâncias de banco de dados MariaDB 10.5, esse novo privilégio não é concedido ao usuário principal do RDS.
## Exemplos
O exemplo a seguir mostra o status de uma réplica de leitura MariaDB:
```
call mysql.rds_replica_status;
```
A resposta é semelhante à seguinte:
```
*************************** 1. row ***************************
Replica_IO_State: Waiting for master to send event
Source_Host: XX.XX.XX.XXX
Source_User: rdsrepladmin
Source_Port: 3306
Connect_Retry: 60
Source_Log_File: mysql-bin-changelog.003988
Read_Source_Log_Pos: 405
Relay_Log_File: relaylog.011024
Relay_Log_Pos: 657
Relay_Source_Log_File: mysql-bin-changelog.003988
Replica_IO_Running: Yes
Replica_SQL_Running: Yes
Replicate_Do_DB:
Replicate_Ignore_DB:
Replicate_Do_Table:
Replicate_Ignore_Table: mysql.rds_sysinfo,mysql.rds_history,mysql.rds_replication_status
Replicate_Wild_Do_Table:
Replicate_Wild_Ignore_Table:
Last_Errno: 0
Last_Error:
Skip_Counter: 0
Exec_Source_Log_Pos: 405
Relay_Log_Space: 1016
Until_Condition: None
Until_Log_File:
Until_Log_Pos: 0
Source_SSL_Allowed: No
Source_SSL_CA_File:
Source_SSL_CA_Path:
Source_SSL_Cert:
Source_SSL_Cipher:
Source_SSL_Key:
Seconds_Behind_Master: 0
Source_SSL_Verify_Server_Cert: No
Last_IO_Errno: 0
Last_IO_Error:
Last_SQL_Errno: 0
Last_SQL_Error:
Replicate_Ignore_Server_Ids:
Source_Server_Id: 807509301
Source_SSL_Crl:
Source_SSL_Crlpath:
Using_Gtid: Slave_Pos
Gtid_IO_Pos: 0-807509301-3980
Replicate_Do_Domain_Ids:
Replicate_Ignore_Domain_Ids:
Parallel_Mode: optimistic
SQL_Delay: 0
SQL_Remaining_Delay: NULL
Replica_SQL_Running_State: Reading event from the relay log
Replica_DDL_Groups: 15
Replica_Non_Transactional_Groups: 0
Replica_Transactional_Groups: 3658
1 row in set (0.000 sec)
Query OK, 0 rows affected (0.000 sec)
```
# mysql.rds\$1set\$1external\$1master\$1gtid
Configura a replicação baseada em GTID de uma instância do MariaDB executada externamente em relação ao Amazon RDS para uma instância de banco de dados MariaDB. Esse procedimento armazenado é compatível apenas com a versão 10.0.24 ou posteriores da instância externa do MariaDB. Ao configurar a replicação na qual uma ou ambas as instâncias não oferecem suporte a identificadores de transações globais (GTIDs) do MariaDB, use [mysql.rds\$1set\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](mysql-stored-proc-replicating.md#mysql_rds_set_external_master).
O uso de GTIDs para replicação oferece recursos de segurança contra falhas não disponibilizados pela replicação de log binário, por isso recomendamos nos casos em que há o suporte pelas instâncias de replicação.
## Sintaxe
```
CALL mysql.rds_set_external_master_gtid(
host_name
, host_port
, replication_user_name
, replication_user_password
, gtid
, ssl_encryption
);
```
## Parâmetros
*host\$1name*
String. O nome de host ou o endereço IP da instância do MariaDB sendo executada externamente ao Amazon RDS que se tornará a instância de origem.
*host\$1port*
Inteiro. A porta usada para executar a instância do MariaDB sendo executada externamente ao Amazon RDS a ser configurada como a instância de origem. Se sua configuração de rede inclui replicação de porta SSH que converte o número da porta, especifique o número da porta exposto pelo SSH.
*replication\$1user\$1name*
String. O ID de um usuário com permissões `REPLICATION SLAVE` na instância de banco de dados MariaDB deve ser configurado como a réplica de leitura.
*replication\$1user\$1password*
String. A senha do ID de usuário especificada em `replication_user_name`.
*gtid*
String. O ID da transação global na instância de origem a partir da qual a replicação deve iniciar.
É possível usar o `@@gtid_current_pos` para obter o GTID atual se a instância de origem tiver sido bloqueada enquanto você estiver configurando a replicação, de modo que o log binário não mude entre os pontos quando você obtiver o GTID e quando a replicação iniciar.
Caso contrário, se você estiver usando o `mysqldump` versão 10.0.13 ou posterior para preencher a instância de réplica antes de iniciar a replicação, será possível obter a posição de GTID na saída usando as opções `--master-data` ou `--dump-slave`. Se você não estiver usando o `mysqldump` versão 10.0.13 ou superior, você poderá executar o `SHOW MASTER STATUS` ou usar as mesmas opções de `mysqldump` para obter o nome e a posição do arquivo de log binário, convertê-los em um GTID executando `BINLOG_GTID_POS` na instância externa do MariaDB:
```
SELECT BINLOG_GTID_POS('', );
```
Para obter mais informações sobre a implantação de GTIDs do MariaDB, acesse [Global Transaction ID](http://mariadb.com/kb/en/mariadb/global-transaction-id/) na documentação do MariaDB.
*ssl\$1encryption*
Um valor que especifica se a criptografia do Secure Sockets Layer (SSL) será usada na conexão de replicação. 1 especifica para usar criptografia de SSL, 0 especifica para não usar criptografia. O padrão é 0.
A opção `MASTER_SSL_VERIFY_SERVER_CERT` não tem suporte. Essa opção é definida como 0, o que significa que a conexão é criptografada, mas os certificados não são verificados.
## Observações de uso
O procedimento `mysql.rds_set_external_master_gtid` deve ser executado pelo usuário mestre. Ele deve ser executado na instância de banco de dados MariaDB que você está configurando como a réplica de uma instância do MariaDB, sendo executada externamente ao Amazon RDS. Antes de executar `mysql.rds_set_external_master_gtid`, é necessário configurar a instância do MariaDB sendo executada externamente ao Amazon RDS como uma instância de origem. Para obter mais informações, consulte [Importar dados para uma instância de banco de dados do Amazon RDS para MariaDB](MariaDB.Procedural.Importing.md).
**Atenção**
Não use o `mysql.rds_set_external_master_gtid` para gerenciar uma replicação entre duas instâncias de banco de dados do Amazon RDS. Use-o apenas ao replicar com uma instância MariaDB sendo executada externamente ao RDS. Para obter informações sobre como gerenciar a replicação entre instâncias de banco de dados do Amazon RDS, consulte [Trabalhar com réplicas de leitura de instância de banco de dados](USER_ReadRepl.md).
Após chamar `mysql.rds_set_external_master_gtid` para configurar uma instância de banco de dados do Amazon RDS como uma réplica de leitura, você poderá chamar [mysql.rds\$1start\$1replication](mysql-stored-proc-replicating.md#mysql_rds_start_replication) na réplica para iniciar o processo de replicação. É possível chamar [mysql.rds\$1reset\$1external\$1master (RDS para MariaDB e RDS para MySQL versões principais 8.0 e anteriores)](mysql-stored-proc-replicating.md#mysql_rds_reset_external_master) para remover a configuração da réplica de leitura.
Quando `mysql.rds_set_external_master_gtid` é chamado, o Amazon RDS grava a hora, o usuário e uma ação do "mestre do conjunto" nas tabelas `mysql.rds_history` e `mysql.rds_replication_status`.
## Exemplos
Quando executado em uma instância de banco de dados MariaDB, o exemplo a seguir o configura como a réplica de uma instância do MariaDB sendo executada externamente ao Amazon RDS.
```
call mysql.rds_set_external_master_gtid ('Sourcedb.some.com',3306,'ReplicationUser','SomePassW0rd','0-123-456',0);
```
# mysql.rds\$1kill\$1query\$1id
Encerra uma consulta em execução no servidor do MariaDB para terminar consultas problemáticas ou de longa duração. É possível identificar o ID da consulta e interromper efetivamente uma consulta específica para resolver problemas de desempenho e manter a operação ideal do banco de dados.
## Sintaxe
```
CALL mysql.rds_kill_query_id(queryID);
```
## Parâmetros
*queryID*
Inteiro. A identidade da consulta a ser encerrada.
## Observações de uso
Para encerrar uma consulta em execução no servidor do MariaDB, use o procedimento `mysql.rds_kill_query_id` e passe o ID da consulta. Para obter o ID da consulta, consulte a [Tabela Information schema PROCESSLIST](http://mariadb.com/kb/en/mariadb/information-schema-processlist-table/) do MariaDB, como mostrado a seguir:
```
SELECT USER, HOST, COMMAND, TIME, STATE, INFO, QUERY_ID FROM
INFORMATION_SCHEMA.PROCESSLIST WHERE USER = '';
```
A conexão ao servidor do MariaDB é retida.
## Exemplos
O exemplo a seguir encerra uma consulta com um ID de consulta de 230040:
```
call mysql.rds_kill_query_id(230040);
```
# mysql.rds\$1execute\$1operation
Executa operações do InnoDB para gerenciar estados de grupo de buffers e espaços para tabela temporários. Esse procedimento pode ser usado para controlar dinamicamente as operações do InnoDB, como despejar e carregar estados do grupo de buffers ou truncar o espaço para tabela temporário.
## Sintaxe
```
CALL mysql.rds_execute_operation(operation);
```
## Parâmetros
*Operação do*
String. As operações do InnoDB a serem executadas. Os valores válidos são:
+ *innodb\$1buffer\$1pool\$1dump\$1now*: operação que despeja o estado atual do grupo de buffers.
+ *innodb\$1buffer\$1pool\$1load\$1now*: operação que carrega o estado do grupo de buffers salvo.
+ *innodb\$1buffer\$1pool\$1load\$1abort*: operação que cancela uma operação de carregamento do grupo de buffers.
+ *innodb\$1truncate\$1temporary\$1tablespace\$1now*: operação que trunca o espaço para tabela temporário.
## Observações de uso
Esse procedimento só é compatível com instâncias de banco de dados MariaDB que executam MariaDB versão 11.8 e versões posteriores.
Durante a execução, o registro em log binário é temporariamente desabilitado para impedir a replicação desses comandos administrativos.
O procedimento mantém uma trilha de auditoria registrando em log todas as operações na tabela [https://mariadb.com/docs/server/security/securing-mariadb/securing-mariadb-encryption/data-in-transit-encryption/securing-connections-for-client-and-server#requiring-tls](https://mariadb.com/docs/server/security/securing-mariadb/securing-mariadb-encryption/data-in-transit-encryption/securing-connections-for-client-and-server#requiring-tls).
## Exemplos
O exemplo a seguir demonstra a redução temporária do espaço para tabela usando `mysql.rds_execute_operation`:
Para conferir o tamanho atual do espaço para tabela temporário, execute a seguinte consulta:
```
SELECT FILE_SIZE FROM information_schema.innodb_sys_tablespaces WHERE name LIKE 'innodb_temporary';
+------------+
| FILE_SIZE |
+------------+
| 6723469312 | -- 6.3 GB
+------------+
```
Quando você elimina tabelas temporárias, isso não reduz o uso de armazenamento no espaço para tabela global. Para reduzir o tamanho do espaço para tabela global, execute o comando `mysql.rds_execute_operation` para reduzir o espaço para tabela temporário.
```
CALL mysql.rds_execute_operation('innodb_truncate_temporary_tablespace_now');
Query OK, 2 rows affected (0.004 sec)
```
Depois de executar o procedimento, verifique se o espaço foi recuperado.
```
SELECT FILE_SIZE FROM information_schema.innodb_sys_tablespaces WHERE name LIKE 'innodb_temporary';
+-----------+
| FILE_SIZE |
+-----------+
| 12582912 | -- 12 MB
+-----------+
```
**nota**
A operação de redução pode levar algum tempo, dependendo do tamanho do espaço para tabela temporário e da workload atual.
**Importante**
O espaço para tabela temporário diminui somente quando todas as tabelas temporárias que contribuíram para seu tamanho não estão mais em uso. Recomendamos que você execute esse procedimento quando não houver espaços para tabela temporários ativos na instância.
# Fuso horário local para as instâncias de banco de dados do MariaDB
Por padrão, o fuso horário de uma instância de banco de dados MariaDB é o Tempo Universal Coordenado (UTC). Você pode definir o fuso horário de sua instância de banco de dados como o fuso horário local de seu aplicativo.
Para definir o fuso horário local de uma instância de banco de dados, defina o parâmetro `time_zone` no grupo de parâmetros para sua instância de banco de dados como um dos valores compatíveis listados posteriormente nesta seção. Quando você configura o parâmetro `time_zone` para um grupo de parâmetros, todas as instâncias de banco de dados e as réplicas de leitura que estiverem usando esse grupo de parâmetros mudarão para usar o novo fuso horário local. Para obter informações sobre como configurar parâmetros em um grupo de parâmetros, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
Após definir o fuso horário local, todas as novas conexões ao banco de dados refletirão a alteração. Se você tiver conexões abertas em seu banco de dados quando mudar o fuso horário local, você não verá a atualização do fuso horário local até que encerre a conexão e abra uma nova conexão.
É possível definir um fuso horário local diferente para uma instância de banco de dados e uma ou mais de suas réplicas de leitura. Para fazer isso, use um grupo de parâmetros diferente para a instância de banco de dados e a(s) replica(s), e defina o parâmetro `time_zone` em cada grupo de parâmetros para um fuso horário local diferente.
Se você estiver replicando entre as Regiões da AWS, a instância de banco de dados de origem e a réplica de leitura usarão grupos de parâmetros diferentes (os grupos de parâmetros são exclusivos de cada Região da AWS). Para usar o mesmo fuso horário local a cada instância, é necessário configurar o parâmetro `time_zone` nos grupos de parâmetros da instância e da réplica de leitura.
Quando você restaura uma instância de banco de dados de um snapshot de banco de dados, o fuso horário local é definido como UTC. Você pode atualizar o fuso horário para o fuso horário local após a conclusão da restauração. Se você restaurar uma instância de banco de dados para um período específico, o fuso horário local para a instância de banco de dados restaurada representará a configuração de fuso horário do grupo de parâmetros da instância de banco de dados restaurada.
A Internet Assigned Numbers Authority (IANA) publica novos fusos horários em [https://www.iana.org/time-zones](https://www.iana.org/time-zones) várias vezes por ano. Toda vez que o RDS lança uma nova versão de manutenção secundária do MariaDB, ela vem com os dados de fuso horário mais recentes no momento do lançamento. Ao usar as versões mais recentes do RDS para MariaDB, você tem dados de fuso horário recentes do RDS. Para garantir que sua instância de banco de dados tenha dados de fuso horário recentes, recomendamos atualizar para uma versão superior do mecanismo de banco de dados. Como alternativa, você pode modificar as tabelas de fuso horário nas instâncias de banco de dados do MariaDB manualmente. Para fazer isso, você pode usar comandos SQL ou executar a [ferramenta mysql\$1tzinfo\$1to\$1sql](https://mariadb.com/kb/en/mysql_tzinfo_to_sql/) em um cliente SQL. Depois de atualizar os dados do fuso horário manualmente, reinicialize sua instância de banco de dados para que as alterações tenham efeito. O RDS não modifica nem redefine os dados de fuso horário das instâncias de banco de dados em execução. Os novos dados de fuso horário são instalados somente quando você executa uma atualização da versão do mecanismo de banco de dados.
Você pode definir seu fuso horário local para um dos seguintes valores.
| Zona | Time zone (Fuso horário) |
| --- | --- |
| África | África/Cairo, África/Casablanca, África/Harare, África/Monrovia, África/Nairobi, África/Tripoli, África/Windhoek |
| América | América/Araguaina, América/Assunção, América/Bogotá, América/Buenos\$1Aires, América/Caracas, América/Chihuahua, América/Cuiabá, América/Denver, América/Fortaleza, América/Guatemala, América/Halifax, América/Manaus, América/Matamoros, América/Monterrey, América/Montevidéu, América/Phoenix, América/Santiago, América/Tijuana |
| Ásia | Ásia/Amman, Ásia/Ashgabat, Ásia/Baghdad, Ásia/Baku, Ásia/Bangkok, Ásia/Beirut, Ásia/Calcutta, Ásia/Damascus, Ásia/Dhaka, Ásia/Irkutsk, Ásia/Jerusalem, Ásia/Kabul, Ásia/Karachi, Ásia/Kathmandu, Ásia/Krasnoyarsk, Ásia/Magadan, Ásia/Muscat, Ásia/Novosibirsk, Ásia/Riyadh, Ásia/Seoul, Ásia/Shanghai, Ásia/Singapore, Ásia/Taipei, Ásia/Tehran, Ásia/Tokyo, Ásia/Ulaanbaatar, Ásia/Vladivostok, Ásia/Yakutsk, Ásia/Yerevan |
| Atlântico | Atlântico/Açores |
| Austrália | Austrália/Adelaide, Austrália/Brisbane, Austrália/Darwin, Austrália/Hobart, Austrália/Perth, Austrália/Sydney |
| Brasil | Brasil/DeNoronha, Brasil/Leste |
| Canadá | Canadá/Newfoundland, Canadá/Saskatchewan, Canadá/Yukon |
| Europa | Europa/Amsterdam, Europa/Athens, Europa/Dublin, Europa/Helsinki, Europa/Istanbul, Europa/Kaliningrad, Europa/Moscow, Europa/Paris, Europa/Prague, Europa/Sarajevo |
| Pacífico | Pacífico/Auckland, Pacífico/Fiji, Pacífico/Guam, Pacífico/Honolulu, Pacífico/Samoa |
| EUA | EUA/Alasca, EUA/Central, EUA/East-Indiana, EUA/Eastern, EUA/Pacífico |
| UTC | UTC |
# Limitações e problemas conhecidos do RDS para MariaDB
Os itens a seguir referem-se a limitações e problemas conhecidos no uso do RDS para MariaDB.
**nota**
Essa lista não é exaustiva.
**Topics**
+ [Limites de tamanho de arquivo do MariaDB no Amazon RDS](#RDS_Limits.FileSize.MariaDB)
+ [Palavra reservada InnoDB](#MariaDB.Concepts.InnodbDatabaseName)
+ [Portas personalizadas](#MariaDB.Concepts.CustomPorts)
+ [Insights de Performance](#MariaDB.Concepts.PerformanceInsights)
## Limites de tamanho de arquivo do MariaDB no Amazon RDS
Para instâncias de banco de dados do MariaDB, o tamanho máximo de uma tabela é 16 TB ao usar tablespaces de arquivo por tabela do InnoDB. Esse limite também restringe o espaço de tabela do sistema a um tamanho máximo de 16 TB. Os espaços de tabelas de arquivo por tabela do InnoDB (com cada tabela em seu próprio espaço de tabela) são definidos por padrão para instâncias de bancos de dados MariaDB. Esse limite não está relacionado ao limite máximo de armazenamento para instâncias de banco de dados do MariaDB. Para obter mais informações sobre limites de armazenamento, consulte [Armazenamento de instâncias de banco de dados do Amazon RDS](CHAP_Storage.md).
Existem vantagens e desvantagens na utilização de espaços de tabela de arquivo por tabela do InnoDB, dependendo do seu aplicativo. Para determinar a melhor abordagem para a aplicação, consulte [File-per-table tablespaces](https://dev.mysql.com/doc/refman/5.7/en/innodb-file-per-table-tablespaces.html) na documentação do MySQL.
Não recomendamos permitir que as tabelas cresçam até o tamanho máximo do arquivo. Em geral, uma prática recomendada é particionar dados em tabelas menores, o que pode melhorar a performance e os tempos de recuperação.
Uma opção que você pode usar para dividir uma tabela grande em tabelas menores é o particionamento. O *particionamento* distribui partes da sua tabela grande em arquivos separados com base em regras que você especifica. Por exemplo, se você armazenar transações por data, poderá criar regras de particionamento que distribuem transações antigas em arquivos separados usando o particionamento. Em seguida, periodicamente, você pode arquivar os dados históricos de transações que não precisam estar prontamente disponíveis para o seu aplicativo. Para ter mais informações, consulte [Partitioning](https://dev.mysql.com/doc/refman/5.7/en/partitioning.html) na documentação do MySQL.
**Como determinar o tamanho de todos os espaços de tabela do InnoDB**
+ Use o seguinte comando SQL para determinar se algumas das suas tabelas são muito grandes e são candidatas para particionamento.
**nota**
No MariaDB 10.6 e posterior, essa consulta também retorna o tamanho do espaço de tabela do sistema InnoDB.
Em versões do MariaDB anteriores à 10.6, não é possível determinar o tamanho do espaço de tabela do sistema InnoDB consultando as tabelas do sistema. Recomendamos fazer upgrade para uma versão posterior.
```
1. SELECT SPACE,NAME,ROUND((ALLOCATED_SIZE/1024/1024/1024), 2)
2. as "Tablespace Size (GB)"
3. FROM information_schema.INNODB_SYS_TABLESPACES ORDER BY 3 DESC;
```
**Como determinar o tamanho das tabelas de usuários que não são do InnoDB**
+ Use o seguinte comando SQL para determinar se algumas das suas tabelas de usuários que não são do InnoDB são muito grandes.
```
SELECT TABLE_SCHEMA, TABLE_NAME, round(((DATA_LENGTH + INDEX_LENGTH+DATA_FREE)
/ 1024 / 1024/ 1024), 2) As "Approximate size (GB)" FROM information_schema.TABLES
WHERE TABLE_SCHEMA NOT IN ('mysql', 'information_schema', 'performance_schema')
and ENGINE<>'InnoDB';
```
**Para habilitar espaços de tabela de arquivo por tabela do InnoDB**
+ Defina o parâmetro `innodb_file_per_table` como `1` no grupo de parâmetros da instância de banco de dados.
**Para desabilitar espaços de tabela de arquivo por tabela do InnoDB**
+ Defina o parâmetro `innodb_file_per_table` como `0` no grupo de parâmetros da instância de banco de dados.
Para obter informações sobre como atualizar um grupo de parâmetros, consulte [Grupos de parâmetros para Amazon RDS](USER_WorkingWithParamGroups.md).
Ao ativar ou desativar os espaços de tabela de arquivo por tabela do InnoDB, você pode emitir um comando `ALTER TABLE`. Você pode usar esse comando para mover uma tabela do espaço de tabela global para seu próprio espaço de tabela. Ou você pode mover uma tabela de seu próprio espaço de tabela para o espaço de tabela global. Veja um exemplo a seguir.
```
1. ALTER TABLE table_name ENGINE=InnoDB, ALGORITHM=COPY;
```
## Palavra reservada InnoDB
`InnoDB` é uma palavra reservada ao RDS para MariaDB. Não é possível usar esse nome para um banco de dados do MariaDB.
## Portas personalizadas
O Amazon RDS bloqueia conexões com a porta personalizada 33060 para o mecanismo MariaDB. Escolha uma porta diferente para o seu mecanismo MariaDB.
## Insights de Performance
Os contadores do InnoDB não estão visíveis no Insights de Performance para o RDS para MariaDB versão 10.11 porque não há mais suporte para eles na comunidade do MariaDB.