# Monitorar o Amazon Aurora com o recurso Database Activity Streams Usando o recurso Database Activity Streams, você pode monitorar fluxos quase em tempo real da atividade de um banco de dados. **Topics** + [ ## Visão geral dos Database Activity Streams ](#DBActivityStreams.Overview) + [ # Pré-requisitos de rede para fluxos de atividades de banco de dados Aurora MySQL ](DBActivityStreams.Prereqs.md) + [ # Iniciar um stream de atividade de banco de dados ](DBActivityStreams.Enabling.md) + [ # Obter o status de um fluxo de atividade de banco de dados ](DBActivityStreams.Status.md) + [ # Interromper um fluxo de atividade de banco de dados ](DBActivityStreams.Disabling.md) + [ # Monitorar fluxos de atividades de banco de dados ](DBActivityStreams.Monitoring.md) + [ # Exemplos de políticas do IAM para fluxos de atividades de banco de dados ](DBActivityStreams.ManagingAccess.md) ## Visão geral dos Database Activity Streams Como administrador de um banco de dados do Amazon Aurora, você precisa proteger o banco de dados e atender aos requisitos regulatórios e de compatibilidade. Uma estratégia é integrar fluxos de atividades de banco de dados às suas ferramentas de monitoramento. Dessa forma, você monitora e define alarmes para realizar a auditoria da atividade no cluster do Amazon Aurora. As ameaças à segurança são externas e internas. Para se proteger contra ameaças internas, você pode controlar o acesso do administrador aos transmissões de dados configurando o recurso Database Activity Streams. Os administradores de bancos de dados não têm acesso à coleta, transmissão, armazenamento e processamento das transmissões. **Contents** + [ ### Como os fluxos de atividade do banco de dados funcionam ](#DBActivityStreams.Overview.how-they-work) + [ ### Modo assíncrono e síncronopara fluxos de atividades de banco de dados ](#DBActivityStreams.Overview.sync-mode) + [ ### Requisitos e limitações para fluxos de atividade de banco de dados ](#DBActivityStreams.Overview.requirements) + [ ### Disponibilidade de regiões e versões ](#DBActivityStreams.Overview.Availability) + [ ### Classes de instância de banco de dados compatíveis para transmissões de atividades de banco de dados ](#DBActivityStreams.Overview.requirements.classes) ### Como os fluxos de atividade do banco de dados funcionam No Amazon Aurora, você inicia um fluxo de atividades de banco de dados no nível do cluster. Todas as instâncias de banco de dados no cluster têm fluxos de atividades de banco de dados habilitados. Seu cluster de banco de dados do Aurora envia atividades para um fluxo de dados do Amazon Kinesis quase em tempo real. O fluxo do Kinesis é criado automaticamente. No Kinesis, é possível configurar serviços da AWS, como o Amazon Data Firehose e o AWS Lambda, para consumir o fluxo e armazenar os dados. **Importante** O uso do recurso Database Activity Streams é gratuito no Amazon Aurora, mas o Amazon Kinesis cobra pelo fluxo de dados. Para ter mais informações, consulte [Definição de preço do Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/pricing/). Se você usar um banco de dados global do Aurora, inicie um fluxo de atividades de banco de dados em cada cluster de banco de dados separadamente. Cada cluster fornece dados de auditoria ao seu próprio fluxo do Kinesis dentro de sua própria Região da AWS. Os fluxos de atividade não funcionam de forma diferente durante um failover. Eles continuam a auditar seu banco de dados global como de costume. É possível configurar aplicações para gerenciamento de conformidade com o objetivo de consumir fluxos de atividades do banco de dados. No Aurora PostgreSQL, as aplicações de conformidade incluem o IBM Security Guardium e o Imperva SecureSphere Database Audit and Protection. Essas aplicações podem usar o fluxo para gerar alertas e auditar atividades em seu cluster de banco de dados Aurora. O gráfico a seguir mostra um cluster de banco de dados do Aurora configurado com o Amazon Data Firehose. ![\[Diagrama de arquitetura mostrando fluxos de atividades do banco de dados de um cluster de banco de dados do Aurora consumido pelo Firehose\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/AuroraUserGuide/images/aurora-das.png) ### Modo assíncrono e síncronopara fluxos de atividades de banco de dados Você pode decidir se prefere que a sessão de banco de dados processe os eventos de atividade de banco de dados em um destes modos: + **Modo assíncrono**: quando uma sessão de banco de dados gera um evento de fluxo de atividade, a sessão retorna às atividades normais imediatamente. Em segundo plano, o evento do fluxo de atividade é tornado um registro durável. Se ocorrer um erro na tarefa de segundo plano, é enviado um evento do RDS. Este evento indica o início e o final de qualquer janela de tempo em que os registros do evento do fluxo de atividade podem ter sido perdidos. O modo assíncrono favorece a performance do banco de dados sobre a precisão do fluxo de atividade. **nota** O modo assíncrono está disponível para o Aurora PostgreSQL e o Aurora MySQL. + **Modo síncrono:** quando uma sessão de banco de dados gera um evento de fluxo de atividade, a sessão bloqueia outras atividades até que o evento torne-se durável. Se não puder tornar o evento por algum motivo, a sessão de banco de dados retorna às atividades normais. No entanto, um evento do RDS é enviado, indicando que os registros do fluxo de atividade podem ser perdidos por algum tempo. Um segundo evento do RDS é enviado depois que o sistema voltar a um estado íntegro. O modo síncrono favorece a precisão do fluxo de atividade sobre a performance do banco de dados. **nota** O modo síncrono está disponível para o Aurora PostgreSQL. Não é possível usar o modo síncrono com o Aurora MySQL. ### Requisitos e limitações para fluxos de atividade de banco de dados No Aurora, os fluxos de atividade de banco de dados têm os seguintes requisitos e limites: + O Amazon Kinesis é imprescindível para os fluxos de atividades do banco de dados. + O AWS Key Management Service (AWS KMS) é imprescindível para fluxos de atividades de banco de dados, pois eles são sempre criptografados. + A aplicação de criptografia adicional ao seu fluxo de dados do Amazon Kinesis é incompatível com fluxos de atividade do banco de dados, que já estão criptografados com sua chave do AWS KMS. + Inicie o fluxo de atividades do banco de dados no nível do cluster de banco de dados. Se você adicionar uma instância de banco de dados ao cluster, não precisará iniciar um fluxo de atividades na instância: ele é auditado automaticamente. + No banco de dados global do Aurora, inicie um fluxo de atividades em cada cluster de banco de dados separadamente. Cada cluster fornece dados de auditoria ao seu próprio fluxo do Kinesis dentro de sua própria Região da AWS. + No Aurora PostgreSQL, interrompa o fluxo de atividades do banco de dados antes de uma atualização de versão principal. Você poderá iniciar o fluxo de atividades do banco de dados após o término da atualização. ### Disponibilidade de regiões e versões A disponibilidade e a compatibilidade de recursos variam entre versões específicas de cada mecanismo de banco de dados do Aurora e entre Regiões da AWS. Para ter mais informações sobre a disponibilidade de versões e regiões com o Aurora e fluxos de atividades de banco de dados, consulte [Regiões e mecanismos de banco de dados do Aurora compatíveis com fluxos de atividades de banco de dados](Concepts.Aurora_Fea_Regions_DB-eng.Feature.DBActivityStreams.md). ### Classes de instância de banco de dados compatíveis para transmissões de atividades de banco de dados Para o Aurora MySQL, é possível utilizar fluxos de atividades de banco de dados com as seguintes classes de instâncias de banco de dados: + db.r8g.\$1large + db.r7g.\$1large + db.r7i.\$1large + db.r6g.\$1large + db.r6i.\$1large + db.r5.\$1large + db.x2g.\$1 Para o Aurora PostgreSQL, é possível utilizar fluxos de atividades de banco de dados com as seguintes classes de instâncias de banco de dados: + db.r8g.\$1large + db.r7i.\$1large + db.r7g.\$1large + db.r6g.\$1large + db.r6i.\$1large + db.r6id.\$1large + db.r5.\$1large + db.r4.\$1large + db.x2g.\$1 # Pré-requisitos de rede para fluxos de atividades de banco de dados Aurora MySQL Na seção a seguir, você aprende a configurar sua nuvem privada virtual (VPC) para uso com transmissões de atividades de banco de dados. **nota** Os pré-requisitos de rede do Aurora MySQL são aplicáveis às seguintes versões do mecanismo: Aurora MySQL versão 2, até 2.11.3 Aurora MySQL versão 2.12.0 Aurora MySQL versão 3, até 3.04.2 **Topics** + [ ## Pré-requisitos para endpoints do AWS KMS ](#DBActivityStreams.Prereqs.KMS) + [ ## Pré-requisitos para a disponibilidade pública ](#DBActivityStreams.Prereqs.Public) + [ ## Pré-requisitos para a disponibilidade privada ](#DBActivityStreams.Prereqs.Private) ## Pré-requisitos para endpoints do AWS KMS Instâncias em um cluster Aurora MySQL que usam fluxos de atividade que devem ser capazes de acessar endpoints do AWS KMS. Certifique-se de que este requisito esteja satisfeito antes de ativar fluxos de atividades de banco de dados para o Aurora MySQL cluster. Se o cluster do Aurora estiver disponível publicamente, esse requisito será cumprido automaticamente. **Importante** Se o cluster Aurora MySQL de banco de dados não conseguir acessar o endpoint do AWS KMS, o fluxo de atividade será interrompido. Nesse caso, o Aurora notifica você sobre esse problema usando os eventos do RDS. ## Pré-requisitos para a disponibilidade pública Para que um cluster de bancos de dados Aurora seja público, deverá atender aos seguintes requisitos: + Na página de detalhes do cluster do Console de gerenciamento da AWS, a opção **Publicly Accessible** (Acessível para o público) será **Yes** (Sim). + O cluster de banco de dados está em uma sub-rede pública da Amazon VPC. Para obter mais informações sobre instâncias de bancos de dados publicamente acessíveis, consulte [Trabalhar com um cluster de banco de dados em uma VPC](USER_VPC.WorkingWithRDSInstanceinaVPC.md). Para obter mais informações sobre sub-redes públicas da Amazon VPC, consulte [VPC e sub-redes.](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html) ## Pré-requisitos para a disponibilidade privada Se o cluster de banco de dados do Aurora estiver em uma sub-rede pública de VPC e não estiver acessível ao público, ele é privado. Para manter o seu cluster privado e usá-lo com fluxos de atividades de banco de dados, você pode optar pelo seguinte: + Configure a conversão de endereços de rede (NAT) em sua VPC. Para obter mais informações, consulte [Gateways NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html). + Crie um endpoint do AWS KMS na sua VPC. Recomenda-se essa opção por ser mais fácil de configurar. **Para criar um endpoint do AWS KMS na sua VPC** 1. Abra o console da Amazon VPC em [https://console.aws.amazon.com/vpc/](https://console.aws.amazon.com/vpc/). 1. No painel de navegação, escolha **Endpoints**. 1. Escolha **Create Endpoint** (Criar endpoint). Aparecerá a página **Create Endpoint** (Criar endpoint). 1. Faça o seguinte: + Em **Categoria de serviço**, selecione **Serviços da AWS**. + Em **Service Name** (Nome do serviço), escolha **com.amazonaws.*region*.kms**, onde *region* é a Região da AWS na qual o cluster está localizado. + Em **VPC**, escolha a VPC em que o seu cluster se localiza. 1. Escolha **Create Endpoint** (Criar endpoint). Para obter mais informações sobre como configurar VPC endpoints, consulte [VPC Endpoints](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-endpoints.html). # Iniciar um stream de atividade de banco de dados Para monitorar a atividade de banco de dados para todas as instâncias do cluster de banco de dados do Aurora, inicie um fluxo de atividades no nível do cluster. As instâncias de banco de dados adicionadas ao cluster também são monitoradas automaticamente. Se você usar um banco de dados global do Aurora, inicie um fluxo de atividades de banco de dados em cada cluster de banco de dados separadamente. Cada cluster fornece dados de auditoria ao seu próprio fluxo do Kinesis dentro de sua própria Região da AWS. Ao iniciar um fluxo de atividade, cada evento da atividade do banco de dados que você configurou na política de auditoria gera um evento do fluxo de atividade. Comandos SQL, como `CONNECT` e `SELECT`, geram eventos de acesso. Comandos SQL, como `CREATE` e `INSERT`, geram eventos de alteração. ------ #### [ Console ] **Para iniciar um fluxo de atividade de banco de dados** 1. 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 **Databases (Bancos de dados)**. 1. Escolha o cluster de banco de dados em que deseja iniciar um fluxo de atividade. 1. Em **Actions (Ações)**, escolha **Start activity (Iniciar atividade)**. A janela **Start database activity stream: ***name* (Iniciar fluxo de atividade do banco de dados: nome) aparece. Nela, *name* (nome) é o seu cluster de banco de dados. 1. Insira as seguintes configurações: + Em **AWS KMS key**, escolha uma chave na lista de AWS KMS keys. **nota** Se o cluster do Aurora MySQL não conseguir acessar as chaves do KMS, siga as instruções presentes em [Pré-requisitos de rede para fluxos de atividades de banco de dados Aurora MySQL](DBActivityStreams.Prereqs.md) para habilitar esse acesso primeiro. O Aurora usa a chave do KMS para criptografar a chave que, por sua vez, criptografa a atividade do banco de dados. Escolha uma chave do KMS diferente da chave padrão. Para obter mais informações sobre as chaves de criptografia e o AWS KMS, consulte [O que é o AWS Key Management Service?](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) no *Guia do desenvolvedor do AWS Key Management Service.* + Para **Database activity stream mode (Modo do fluxo de atividade de banco de dados)**, escolha **Asynchronous (Assíncrono)** ou **Synchronous (Síncrono)**. **nota** Essa opção só se aplica ao Aurora PostgreSQL. Para Aurora MySQL, é possível usar apenas o modo assíncrono. + Escolha **Immediately** (Imediatamente). Quando você escolhe **Immediately** (Imediatamente), o cluster de banco de dados reinicia imediatamente. Se você escolher **During the next maintenance window**, (Durante a próxima janela de manutenção), o cluster de banco de dados não reinicia imediatamente. Nesse caso, o stream de atividade do banco de dados não é iniciado até a próxima janela de manutenção. 1. Selecione **Start database activity stream** (Iniciar fluxo de atividades do banco de dados). O status para o cluster de banco de dados mostra que o fluxo de atividade está começando. **nota** Se você receber o erro `You can't start a database activity stream in this configuration`, confira [Classes de instância de banco de dados compatíveis para transmissões de atividades de banco de dados](DBActivityStreams.md#DBActivityStreams.Overview.requirements.classes) para ver se seu cluster de banco de dadossua instância do RDS está usando uma classe de instância compatível. ------ #### [ AWS CLI ] Para iniciar fluxos de atividade de banco de dados para um cluster de banco de dados, configure o cluster de banco de dados utilizando o comando [start-activity-stream](https://docs.aws.amazon.com/cli/latest/reference/rds/start-activity-stream.html) da AWS CLI. + `--resource-arn arn`: especifica o nome do recurso da Amazon (ARN) do cluster de banco de dados. + `--mode sync-or-async`: especifica o modo síncrono (`sync`) ou assíncrono (`async`). No Aurora PostgreSQL, é possível escolher qualquer um dos valores. No Aurora MySQL, especifique `async`. + `--kms-key-id key`: especifica o identificador de chave KMS para criptografar mensagens no fluxo de atividade do banco de dados. O identificador da chave do KMS da AWS é o ARN da chave, o ID da chave ou o ARN do alias ou o nome do alias para AWS KMS key. O exemplo a seguir inicia um fluxo de atividade de banco de dados para um cluster de banco de dados no modo assíncrono. Para Linux, macOS ou Unix: ``` aws rds start-activity-stream \ --mode async \ --kms-key-id my-kms-key-arn \ --resource-arn my-cluster-arn \ --apply-immediately ``` Para Windows: ``` aws rds start-activity-stream ^ --mode async ^ --kms-key-id my-kms-key-arn ^ --resource-arn my-cluster-arn ^ --apply-immediately ``` ------ #### [ Amazon RDS API ] Para iniciar fluxos de atividade de banco de dados para um cluster de banco de dados, configure o cluster utilizando a operação [StartActivityStream](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_StartActivityStream.html). Chame a ação com os parâmetros abaixo: + `Region` + `KmsKeyId` + `ResourceArn` + `Mode` ------ **nota** Se você receber um erro informando que não é possível iniciar um fluxo de atividades do banco de dados com a versão atual do banco de dados Aurora PostgreSQL, aplique o patch mais recente para o Aurora PostgreSQL antes de iniciar um fluxo de atividades do banco de dados. Para ter informações sobre atualizar o banco de dados Aurora PostgreSQL, consulte [Atualização dos clusters de banco de dados do Amazon Aurora](Aurora.VersionPolicy.Upgrading.md). A seguir estão as versões mínimas de patch para iniciar fluxos de atividade de banco de dados com o Aurora PostgreSQL. 3.4.15 (11.9.15), 11.21.10 12.9.15, 12.15.9, 12.16.10, 12.17.7, 12.18.5, 12.19.4, 12.20.3, 12.22.3 13.9.12, 13.11.9, 13.12.10, 13.13.7, 13.14.5, 13.15.4, 13.16.3, 13.18.3 14.6.12, 14.8.9, 14.9.10, 14.10.7, 14.11.5, 14.12.4, 14.13.3, 14.15.3 15.3.9, 15.4.10, 15.5.7, 15.6.5, 15.7.4, 15.8.3, 15.10.3 16.1.7, 16.2.5, 16.3.4, 16.4.3, 16.6.3 # Obter o status de um fluxo de atividade de banco de dados É possível obter o status de um fluxo de atividade usando o console ou a AWS CLI. ## Console **Para obter o status de um fluxo de atividade de banco de dados** 1. 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 **Databases** (Bancos de dados) e escolha o link do cluster de banco de dados. 1. Escolha a guia **Configuração** e verifique o status do **Stream de atividades do banco de dados**. ## AWS CLI É possível obter a configuração do fluxo de atividade para um cluster de banco de dados como a resposta a uma solicitação de CLI [describe-db-clusters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-clusters.html). O exemplo a seguir descreve *my-cluster*. ``` aws rds --region my-region describe-db-clusters --db-cluster-identifier my-cluster ``` O exemplo a seguir mostra uma resposta JSON. Os campos a seguir são mostrados: + `ActivityStreamKinesisStreamName` + `ActivityStreamKmsKeyId` + `ActivityStreamStatus` + `ActivityStreamMode` + Estes campos são os mesmos para o Aurora PostgreSQL e o Aurora MySQL, exceto `ActivityStreamMode` que está sempre `async` para o Aurora MySQL; enquanto para o Aurora PostgreSQL, ele pode ser `sync` ou `async`. ``` { "DBClusters": [ { "DBClusterIdentifier": "my-cluster", ... "ActivityStreamKinesisStreamName": "aws-rds-das-cluster-A6TSYXITZCZXJHIRVFUBZ5LTWY", "ActivityStreamStatus": "starting", "ActivityStreamKmsKeyId": "12345678-abcd-efgh-ijkl-bd041f170262", "ActivityStreamMode": "async", "DbClusterResourceId": "cluster-ABCD123456" ... } ] } ``` ## API do RDS É possível obter a configuração do fluxo de atividades para um cluster de banco de dados como a resposta a uma operação [DescribeDBClusters](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_DescribeDBClusters.html). # Interromper um fluxo de atividade de banco de dados É possível interromper um fluxo de atividade usando o console ou a AWS CLI. Se você excluir seu cluster de banco de dados, o fluxo de atividade será interrompido e o fluxo subjacente do Amazon Kinesis será excluído automaticamente. ## Console **Como desativar um fluxo de atividade** 1. 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 **Databases (Bancos de dados)**. 1. Escolha um cluster de banco de dados de onde deseja interromper o fluxo de atividade de banco de dados. 1. Em **Actions (Ações)**, escolha **Stop activity (Interromper atividade)**. A janela **Database Activity Stream (Fluxo de atividade de banco de dados)** é exibida. 1. Escolha **Immediately** (Imediatamente). Quando você escolhe **Immediately** (Imediatamente), o cluster de banco de dados reinicia imediatamente. Se você escolher **During the next maintenance window**, (Durante a próxima janela de manutenção), o cluster de banco de dados não reinicia imediatamente. Nesse caso, o fluxo de atividade do banco de dados não será interrompido até a próxima janela de manutenção. 1. Escolha **Continue**. ## AWS CLI Para interromper fluxos de atividades de banco de dados para seu cluster de banco de dados, configure o cluster de banco de dados usando o comando da AWS CLI [stop-activity-stream](https://docs.aws.amazon.com/cli/latest/reference/rds/stop-activity-stream.html). Identifique a região da AWS para o cluster de banco de dados usando o parâmetro `--region`. O parâmetro `--apply-immediately` é opcional. Para Linux, macOS ou Unix: ``` aws rds --region MY_REGION \ stop-activity-stream \ --resource-arn MY_CLUSTER_ARN \ --apply-immediately ``` Para Windows: ``` aws rds --region MY_REGION ^ stop-activity-stream ^ --resource-arn MY_CLUSTER_ARN ^ --apply-immediately ``` ## API do RDS Para interromper os fluxos de atividades de banco de dados para o cluster de banco de dados, configure o cluster usando a operação [StopActivityStream](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_StopActivityStream.html). Identifique a região da AWS para o cluster de banco de dados usando o parâmetro `Region`. O parâmetro `ApplyImmediately` é opcional. # Monitorar fluxos de atividades de banco de dados Os fluxos de atividades de banco de dados monitoram e relatam atividades. O stream de atividade é coletado e transmitido para o Amazon Kinesis. No Kinesis, é possível monitorar o stream de atividades ou outros serviços e aplicações podem consumir o stream de atividades para análise posterior. É possível encontrar o nome do fluxo subjacente do Kinesis utilizando o comando `describe-db-clusters` da AWS CLI ou a operação `DescribeDBClusters` da API do RDS. O Aurora gerencia o fluxo do Kinesis para você da seguinte forma: + O Aurora cria o fluxo do Kinesis automaticamente com um período de retenção de 24 horas. + O Aurora escala o fluxo do Kinesis, se necessário. + Se você interromper o fluxo de atividades do banco de dados ou excluir o cluster de banco de dados, o Aurora excluirá o fluxo do Kinesis. As categorias de atividade a seguir são monitoradas e colocadas no log de auditoria do fluxo de atividade: + **Comandos SQL**: todos os comandos SQL são auditados e também instruções preparadas, funções integradas e funções em PL/SQL. Chamadas para procedimentos armazenados são auditadas. Quaisquer instruções SQL emitidas dentro de procedimentos armazenados ou funções também são auditadas. + **Outras informações do banco de dados**: atividades monitoradas incluem a instrução SQL completa, a contagem de linhas afetadas dos comandos DML, os objetos acessados e o nome do banco de dados exclusivo. No Aurora PostgreSQL, os fluxos de atividades de banco de dados também monitoram as variáveis de ligação e os parâmetros de procedimento armazenados. **Importante** O texto SQL completo de cada instrução é visível no log de auditoria do stream de atividades, incluindo quaisquer dados confidenciais. No entanto, as senhas do usuário do banco de dados serão editadas se o Aurora puder determiná-las pelo contexto, como na instrução SQL a seguir. ``` ALTER ROLE role-name WITH password ``` + **Informações de conexão**: a atividade monitorada inclui informações de rede e sessão, o ID do processo de servidor e códigos de saída. Se um fluxo de atividade tiver uma falha ao monitorar uma instância de banco de dados, você será notificado por meio de eventos do RDS. Nas seções a seguir, é possível acessar, auditar e processar fluxos de atividades do banco de dados. **Topics** + [ # Acessar um fluxo de atividades no Amazon Kinesis ](DBActivityStreams.KinesisAccess.md) + [ # Conteúdo do log de auditoria e exemplos de log de fluxos de atividade do banco de dados ](DBActivityStreams.AuditLog.md) + [ # Matriz JSON databaseActivityEventList para fluxos de atividades de banco de dados ](DBActivityStreams.AuditLog.databaseActivityEventList.md) + [ # Processar um fluxo de atividade usando o SDK da AWS ](DBActivityStreams.CodeExample.md) # Acessar um fluxo de atividades no Amazon Kinesis Ao habilitar um fluxo de atividade para um cluster de banco de dados, um fluxo do Kinesis será criado para você. No Kinesis, você pode monitorar a atividade de banco de dados em tempo real. Para analisar detalhadamente a atividade de banco de dados, é possível conectar o stream do Kinesis para aplicações consumidoras. Também é possível conectar o fluxo a aplicações de gerenciamento de compatibilidade como o IBM Security Guardium ou Imperva SecureSphere Database Audit and Protection. Você pode acessar seu fluxo do Kinesis a partir do console do RDS ou do console do Kinesis. **Como acessar um fluxo de atividade pelo Kinesis usando o console do RDS** 1. 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 **Databases (Bancos de dados)**. 1. Escolha o cluster de banco de dados em que iniciou um fluxo de atividade. 1. Escolher **configuração**. 1. Em **Database activity stream** (Fluxo de atividades do banco de dados), clique no link em **Kinesis stream** (Fluxo do Kinesis). 1. No console do Kinesis, selecione **Monitoring** (Monitoramento) para começar a observar a atividade de banco de dados. **Como acessar um fluxo de atividade pelo Kinesis usando o console do Kinesis** 1. Abra o console do Kinesis em [https://console.aws.amazon.com/kinesis](https://console.aws.amazon.com/kinesis). 1. Escolha o fluxo de atividade na lista de fluxos do Kinesis. O nome de um fluxo de atividade contém o prefixo `aws-rds-das-cluster-` seguido pelo ID de recurso do cluster de banco de dados. Veja um exemplo a seguir. ``` aws-rds-das-cluster-NHVOV4PCLWHGF52NP ``` Para utilizar o console do Amazon RDS para encontrar o ID do recurso do cluster de banco de dados, escolha o cluster de banco de dados na lista de bancos de dados e escolha a guia **Configuration** (Configuração). Para utilizar a AWS CLI a fim de encontrar o nome completo do fluxo do Kinesis para um fluxo de atividades, use uma solicitação de CLI [describe-db-clusters](https://docs.aws.amazon.com/cli/latest/reference/rds/describe-db-clusters.html) e anote os valores de `ActivityStreamKinesisStreamName` na resposta. 1. Escolha **Monitoring (Monitoramento)** para começar a observar a atividade de banco de dados. Para obter mais informações sobre como usar o Amazon Kinesis, consulte [O que é o Amazon Kinesis Data Streams?](https://docs.aws.amazon.com/streams/latest/dev/introduction.html). # Conteúdo do log de auditoria e exemplos de log de fluxos de atividade do banco de dados Os eventos monitorados são representados no fluxo de atividade do banco de dados como strings JSON. A estrutura consiste em um objeto JSON que contém um `DatabaseActivityMonitoringRecord`, que, por sua vez, contém uma matriz `databaseActivityEventList` de eventos de atividade. **nota** Para fluxos de atividades do banco de dados, a matriz JSON `paramList` não inclui valores nulos de aplicações Hibernate. **Topics** + [ ## Exemplos de log de auditoria para fluxos de atividade ](#DBActivityStreams.AuditLog.Examples) + [ ## Objeto JSON DatabaseActivityMonitoringRecords ](#DBActivityStreams.AuditLog.DatabaseActivityMonitoringRecords) + [ ## Objeto JSON databaseActivityEvents ](#DBActivityStreams.AuditLog.databaseActivityEvents) ## Exemplos de log de auditoria para fluxos de atividade Veja a seguir exemplos de log de auditoria JSON descriptografados de registros de evento de atividade. **Example Registro de eventos de atividade de uma instrução SQL CONNECT do Aurora PostgreSQL instrução SQL CONNECT** O registro de eventos de atividade a seguir mostra um login com o uso de uma instrução SQL `CONNECT` (`command`) por um cliente psql (`clientApplication`). ``` { "type":"DatabaseActivityMonitoringRecords", "version":"1.1", "databaseActivityEvents": { "type":"DatabaseActivityMonitoringRecord", "clusterId":"cluster-4HNY5V4RRNPKKYB7ICFKE5JBQQ", "instanceId":"db-FZJTMYKCXQBUUZ6VLU7NW3ITCM", "databaseActivityEventList":[ { "startTime": "2019-10-30 00:39:49.940668+00", "logTime": "2019-10-30 00:39:49.990579+00", "statementId": 1, "substatementId": 1, "objectType": null, "command": "CONNECT", "objectName": null, "databaseName": "postgres", "dbUserName": "rdsadmin", "remoteHost": "172.31.3.195", "remotePort": "49804", "sessionId": "5ce5f7f0.474b", "rowCount": null, "commandText": null, "paramList": [], "pid": 18251, "clientApplication": "psql", "exitCode": null, "class": "MISC", "serverVersion": "2.3.1", "serverType": "PostgreSQL", "serviceName": "Amazon Aurora PostgreSQL-Compatible edition", "serverHost": "172.31.3.192", "netProtocol": "TCP", "dbProtocol": "Postgres 3.0", "type": "record", "errorMessage": null } ] }, "key":"decryption-key" } ``` **Example Registro de evento de atividade de uma instrução SQL CONNECT do Aurora MySQL** O registro de eventos de atividade a seguir mostra um login com o uso de uma instrução SQL `CONNECT` (`command`) por um cliente mysql (`clientApplication`). ``` { "type":"DatabaseActivityMonitoringRecord", "clusterId":"cluster-some_id", "instanceId":"db-some_id", "databaseActivityEventList":[ { "logTime":"2020-05-22 18:07:13.267214+00", "type":"record", "clientApplication":null, "pid":2830, "dbUserName":"rdsadmin", "databaseName":"", "remoteHost":"localhost", "remotePort":"11053", "command":"CONNECT", "commandText":"", "paramList":null, "objectType":"TABLE", "objectName":"", "statementId":0, "substatementId":1, "exitCode":"0", "sessionId":"725121", "rowCount":0, "serverHost":"master", "serverType":"MySQL", "serviceName":"Amazon Aurora MySQL", "serverVersion":"MySQL 5.7.12", "startTime":"2020-05-22 18:07:13.267207+00", "endTime":"2020-05-22 18:07:13.267213+00", "transactionId":"0", "dbProtocol":"MySQL", "netProtocol":"TCP", "errorMessage":"", "class":"MAIN" } ] } ``` **Example Registro de evento de atividades de uma instrução CREATE TABLE do Aurora PostgreSQL** O exemplo a seguir mostra um evento `CREATE TABLE` para o Aurora PostgreSQL. ``` { "type":"DatabaseActivityMonitoringRecords", "version":"1.1", "databaseActivityEvents": { "type":"DatabaseActivityMonitoringRecord", "clusterId":"cluster-4HNY5V4RRNPKKYB7ICFKE5JBQQ", "instanceId":"db-FZJTMYKCXQBUUZ6VLU7NW3ITCM", "databaseActivityEventList":[ { "startTime": "2019-05-24 00:36:54.403455+00", "logTime": "2019-05-24 00:36:54.494235+00", "statementId": 2, "substatementId": 1, "objectType": null, "command": "CREATE TABLE", "objectName": null, "databaseName": "postgres", "dbUserName": "rdsadmin", "remoteHost": "172.31.3.195", "remotePort": "34534", "sessionId": "5ce73c6f.7e64", "rowCount": null, "commandText": "create table my_table (id serial primary key, name varchar(32));", "paramList": [], "pid": 32356, "clientApplication": "psql", "exitCode": null, "class": "DDL", "serverVersion": "2.3.1", "serverType": "PostgreSQL", "serviceName": "Amazon Aurora PostgreSQL-Compatible edition", "serverHost": "172.31.3.192", "netProtocol": "TCP", "dbProtocol": "Postgres 3.0", "type": "record", "errorMessage": null } ] }, "key":"decryption-key" } ``` **Example Registro de evento de atividade de uma instrução CREATE TABLE do Aurora MySQL** O exemplo a seguir mostra uma instrução `CREATE TABLE` para o Aurora MySQL. A operação é representada como dois registros de eventos separados. Um evento tem `"class":"MAIN"`. O outro evento tem `"class":"AUX"`. As mensagens podem chegar em qualquer ordem. O campo `logTime` do evento `MAIN` é sempre anterior aos campos `logTime` de quaisquer eventos `AUX` correspondentes. O exemplo a seguir mostra o evento com um valor `class` de `MAIN`. ``` { "type":"DatabaseActivityMonitoringRecord", "clusterId":"cluster-some_id", "instanceId":"db-some_id", "databaseActivityEventList":[ { "logTime":"2020-05-22 18:07:12.250221+00", "type":"record", "clientApplication":null, "pid":2830, "dbUserName":"master", "databaseName":"test", "remoteHost":"localhost", "remotePort":"11054", "command":"QUERY", "commandText":"CREATE TABLE test1 (id INT)", "paramList":null, "objectType":"TABLE", "objectName":"test1", "statementId":65459278, "substatementId":1, "exitCode":"0", "sessionId":"725118", "rowCount":0, "serverHost":"master", "serverType":"MySQL", "serviceName":"Amazon Aurora MySQL", "serverVersion":"MySQL 5.7.12", "startTime":"2020-05-22 18:07:12.226384+00", "endTime":"2020-05-22 18:07:12.250222+00", "transactionId":"0", "dbProtocol":"MySQL", "netProtocol":"TCP", "errorMessage":"", "class":"MAIN" } ] } ``` O exemplo a seguir mostra o evento correspondente a um valor `class` de `AUX`. ``` { "type":"DatabaseActivityMonitoringRecord", "clusterId":"cluster-some_id", "instanceId":"db-some_id", "databaseActivityEventList":[ { "logTime":"2020-05-22 18:07:12.247182+00", "type":"record", "clientApplication":null, "pid":2830, "dbUserName":"master", "databaseName":"test", "remoteHost":"localhost", "remotePort":"11054", "command":"CREATE", "commandText":"test1", "paramList":null, "objectType":"TABLE", "objectName":"test1", "statementId":65459278, "substatementId":2, "exitCode":"", "sessionId":"725118", "rowCount":0, "serverHost":"master", "serverType":"MySQL", "serviceName":"Amazon Aurora MySQL", "serverVersion":"MySQL 5.7.12", "startTime":"2020-05-22 18:07:12.226384+00", "endTime":"2020-05-22 18:07:12.247182+00", "transactionId":"0", "dbProtocol":"MySQL", "netProtocol":"TCP", "errorMessage":"", "class":"AUX" } ] } ``` **Example Registro de evento de atividades de uma instrução SELECT do Aurora PostgreSQL** O exemplo a seguir mostra um evento `SELECT` . ``` { "type":"DatabaseActivityMonitoringRecords", "version":"1.1", "databaseActivityEvents": { "type":"DatabaseActivityMonitoringRecord", "clusterId":"cluster-4HNY5V4RRNPKKYB7ICFKE5JBQQ", "instanceId":"db-FZJTMYKCXQBUUZ6VLU7NW3ITCM", "databaseActivityEventList":[ { "startTime": "2019-05-24 00:39:49.920564+00", "logTime": "2019-05-24 00:39:49.940668+00", "statementId": 6, "substatementId": 1, "objectType": "TABLE", "command": "SELECT", "objectName": "public.my_table", "databaseName": "postgres", "dbUserName": "rdsadmin", "remoteHost": "172.31.3.195", "remotePort": "34534", "sessionId": "5ce73c6f.7e64", "rowCount": 10, "commandText": "select * from my_table;", "paramList": [], "pid": 32356, "clientApplication": "psql", "exitCode": null, "class": "READ", "serverVersion": "2.3.1", "serverType": "PostgreSQL", "serviceName": "Amazon Aurora PostgreSQL-Compatible edition", "serverHost": "172.31.3.192", "netProtocol": "TCP", "dbProtocol": "Postgres 3.0", "type": "record", "errorMessage": null } ] }, "key":"decryption-key" } ``` ``` { "type": "DatabaseActivityMonitoringRecord", "clusterId": "", "instanceId": "db-4JCWQLUZVFYP7DIWP6JVQ77O3Q", "databaseActivityEventList": [ { "class": "TABLE", "clientApplication": "Microsoft SQL Server Management Studio - Query", "command": "SELECT", "commandText": "select * from [testDB].[dbo].[TestTable]", "databaseName": "testDB", "dbProtocol": "SQLSERVER", "dbUserName": "test", "endTime": null, "errorMessage": null, "exitCode": 1, "logTime": "2022-10-06 21:24:59.9422268+00", "netProtocol": null, "objectName": "TestTable", "objectType": "TABLE", "paramList": null, "pid": null, "remoteHost": "local machine", "remotePort": null, "rowCount": 0, "serverHost": "172.31.30.159", "serverType": "SQLSERVER", "serverVersion": "15.00.4073.23.v1.R1", "serviceName": "sqlserver-ee", "sessionId": 62, "startTime": null, "statementId": "0x03baed90412f564fad640ebe51f89b99", "substatementId": 1, "transactionId": "4532935", "type": "record", "engineNativeAuditFields": { "target_database_principal_id": 0, "target_server_principal_id": 0, "target_database_principal_name": "", "server_principal_id": 2, "user_defined_information": "", "response_rows": 0, "database_principal_name": "dbo", "target_server_principal_name": "", "schema_name": "dbo", "is_column_permission": true, "object_id": 581577110, "server_instance_name": "EC2AMAZ-NFUJJNO", "target_server_principal_sid": null, "additional_information": "", "duration_milliseconds": 0, "permission_bitmask": "0x00000000000000000000000000000001", "data_sensitivity_information": "", "session_server_principal_name": "test", "connection_id": "AD3A5084-FB83-45C1-8334-E923459A8109", "audit_schema_version": 1, "database_principal_id": 1, "server_principal_sid": "0x010500000000000515000000bdc2795e2d0717901ba6998cf4010000", "user_defined_event_id": 0, "host_name": "EC2AMAZ-NFUJJNO" } } ] } ``` **Example Registro de evento de atividade de uma instrução SELECT do Aurora MySQL** O exemplo a seguir mostra um evento `SELECT`. O exemplo a seguir mostra o evento com um valor `class` de `MAIN`. ``` { "type":"DatabaseActivityMonitoringRecord", "clusterId":"cluster-some_id", "instanceId":"db-some_id", "databaseActivityEventList":[ { "logTime":"2020-05-22 18:29:57.986467+00", "type":"record", "clientApplication":null, "pid":2830, "dbUserName":"master", "databaseName":"test", "remoteHost":"localhost", "remotePort":"11054", "command":"QUERY", "commandText":"SELECT * FROM test1 WHERE id < 28", "paramList":null, "objectType":"TABLE", "objectName":"test1", "statementId":65469218, "substatementId":1, "exitCode":"0", "sessionId":"726571", "rowCount":2, "serverHost":"master", "serverType":"MySQL", "serviceName":"Amazon Aurora MySQL", "serverVersion":"MySQL 5.7.12", "startTime":"2020-05-22 18:29:57.986364+00", "endTime":"2020-05-22 18:29:57.986467+00", "transactionId":"0", "dbProtocol":"MySQL", "netProtocol":"TCP", "errorMessage":"", "class":"MAIN" } ] } ``` O exemplo a seguir mostra o evento correspondente a um valor `class` de `AUX`. ``` { "type":"DatabaseActivityMonitoringRecord", "instanceId":"db-some_id", "databaseActivityEventList":[ { "logTime":"2020-05-22 18:29:57.986399+00", "type":"record", "clientApplication":null, "pid":2830, "dbUserName":"master", "databaseName":"test", "remoteHost":"localhost", "remotePort":"11054", "command":"READ", "commandText":"test1", "paramList":null, "objectType":"TABLE", "objectName":"test1", "statementId":65469218, "substatementId":2, "exitCode":"", "sessionId":"726571", "rowCount":0, "serverHost":"master", "serverType":"MySQL", "serviceName":"Amazon Aurora MySQL", "serverVersion":"MySQL 5.7.12", "startTime":"2020-05-22 18:29:57.986364+00", "endTime":"2020-05-22 18:29:57.986399+00", "transactionId":"0", "dbProtocol":"MySQL", "netProtocol":"TCP", "errorMessage":"", "class":"AUX" } ] } ``` ## Objeto JSON DatabaseActivityMonitoringRecords Os registros de eventos de atividade de banco de dados estão em um objeto JSON que contém as informações a seguir. **** | Campo JSON | Tipo de dados | Descrição | | --- | --- | --- | | `type` | string | O tipo de registro JSON. O valor é `DatabaseActivityMonitoringRecords`. | | version | string | A versão dos registros de monitoramento de atividade de banco de dados. A versão dos registros de atividade de banco de dados gerados depende da versão do mecanismo do cluster de banco de dados: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.html)Todos os campos a seguir estão na versão 1.0 e na versão 1.1, exceto quando indicado especificamente. | | [databaseActivityEvents](#DBActivityStreams.AuditLog.databaseActivityEvents) | string | Um objeto JSON que contém os eventos de atividade. | | key | string | Uma chave de criptografia que você usa para descriptografar o [Matriz JSON databaseActivityEventList](DBActivityStreams.AuditLog.databaseActivityEventList.md) | ## Objeto JSON databaseActivityEvents O objeto JSON `databaseActivityEvents` contém as informações a seguir. ### Campos de nível superior no registro JSON Cada evento no log de auditoria é incluído em um registro no formato JSON. Esse registro contém os campos a seguir. **type** Esse campo sempre tem o valor `DatabaseActivityMonitoringRecords`. **versão** Esse campo representa a versão do contrato ou do protocolo de dados de streaming da atividade do banco de dados. Define quais campos estão disponíveis. A versão 1.0 representa o suporte de fluxos de atividades de dados originais para o Aurora PostgreSQL versões 10.7 e 11.4. A versão 1.1 representa o suporte de fluxos de atividades de dados para o Aurora PostgreSQL versões 10.10 e posterior e o Aurora PostgreSQL 11.5 e posterior. A versão 1.1 inclui os campos adicionais `errorMessage` e `startTime`. A versão 1.2 representa o suporte de fluxos de atividades de dados para o Aurora MySQL 2.08 e posterior. A versão 1.2 inclui os campos adicionais `endTime` e `transactionId`. **databaseActivityEvents** Uma string criptografada que representa um ou mais eventos de atividade. Ela é representada como uma matriz de bytes base64. Quando você descriptografa a string, o resultado é um registro no formato JSON com campos, conforme mostrado nos exemplos nesta seção. **chave** A chave de dados criptografada usada para criptografar a string `databaseActivityEvents`. Esta é a mesma AWS KMS key que você forneceu ao iniciar o fluxo de atividade do banco de dados. O exemplo a seguir mostra o formato desse registro. ``` { "type":"DatabaseActivityMonitoringRecords", "version":"1.1", "databaseActivityEvents":"encrypted audit records", "key":"encrypted key" } ``` Siga as seguintes etapas para descriptografar o conteúdo do campo `databaseActivityEvents`: 1. Descriptografe o valor no campo JSON da `key` usando a chave do KMS que forneceu ao iniciar o fluxo de atividade do banco de dados. Fazer isso retorna a chave de criptografia de dados em texto não criptografado. 1. Decodifique em base64 o valor no campo JSON `databaseActivityEvents` para obter o texto cifrado, em formato binário, da carga útil de auditoria. 1. Descriptografe o texto cifrado binário com a chave de criptografia de dados que você decodificou na primeira etapa. 1. Descompacte a carga útil descriptografada. + A carga criptografada está no campo `databaseActivityEvents`. + O campo `databaseActivityEventList` contém uma matriz de registros de auditoria. Os campos `type` na matriz podem ser `record` ou `heartbeat`. O registro do evento de atividade do log de auditoria é um objeto JSON que contém as informações a seguir. **** | Campo JSON | Tipo de dados | Descrição | | --- | --- | --- | | `type` | string | O tipo de registro JSON. O valor é `DatabaseActivityMonitoringRecord`. | | clusterId | string | O identificador de recurso de cluster de banco de dados. Corresponde ao atributo de cluster de banco de dados DbClusterResourceId. | | instanceId | string | O identificador de recurso da instância de banco de dados. Ele corresponde ao atributo de instância de banco de dados DbiResourceId. | | [Matriz JSON databaseActivityEventList](DBActivityStreams.AuditLog.databaseActivityEventList.md) | string | Uma matriz de registros de auditoria de atividade ou mensagens de pulsação. | # Matriz JSON databaseActivityEventList para fluxos de atividades de banco de dados A carga do log de auditoria é uma matriz JSON `databaseActivityEventList` criptografada. A tabela a seguir lista em ordem alfabética os campos para cada evento de atividade na matriz `DatabaseActivityEventList` descriptografada de um log de auditoria. Os campos vão diferir, se você usar o Aurora PostgreSQL ou o Aurora MySQL. Consulte a tabela que se aplica ao mecanismo de banco de dados. **Importante** A estrutura do evento está sujeita a alterações. O Aurora pode adicionar novos campos a eventos de atividade no futuro. Em aplicações que analisam os dados JSON, confirme se o código pode ignorar ou executar ações apropriadas para nomes de campo desconhecidos. ## Campos databaseActivityEventList para o Aurora PostgreSQL Veja a seguir campos `databaseActivityEventList` do Aurora PostgreSQL. | Campo | Tipo de dados | Descrição | | --- | --- | --- | | class | string | A classe do evento de atividade. Os valores válidos para o Aurora PostgreSQL são os seguintes: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) | | clientApplication | string | O aplicativo que o cliente usou para conectar-se conforme reportado pelo cliente. O cliente não precisa fornecer essas informações, então o valor pode ser nulo. | | command | string | O nome do comando SQL sem nenhum detalhe do comando. | | commandText | string | A real instrução SQL transmitida pelo usuário. No Aurora PostgreSQL, o valor é idêntico à instrução SQL original. Este campo é usado para todos os tipos de registros, exceto para registros de conexão ou desconexão e, nesse caso, o valor é nulo. O texto SQL completo de cada instrução é visível no log de auditoria do stream de atividades, incluindo quaisquer dados confidenciais. No entanto, as senhas do usuário do banco de dados serão editadas se o Aurora puder determiná-las pelo contexto, como na instrução SQL a seguir. 
ALTER ROLE role-name WITH password
| | databaseName | string | O banco de dados ao qual o usuário se conectou. | | dbProtocol | string | O protocolo de banco de dados, por exemplo Postgres 3.0. | | dbUserName | string | O usuário do banco de dados com o qual o cliente foi autenticado. | | errorMessage(somente registros de atividade de banco de dados da versão 1.1) | string | Se houver algum erro, esse campo será preenchido com a mensagem de erro que seria gerada pelo servidor de banco de dados. O valor `errorMessage` é nulo para instruções normais que não resultaram em um erro. Um erro é definido como qualquer atividade que produziria um evento de log de erro PostgreSQL visível para o cliente em um nível de gravidade igual a `ERROR` ou superior. Para obter mais informações, consulte [PostgreSQL Message Severity Levels](https://www.postgresql.org/docs/current/runtime-config-logging.html#RUNTIME-CONFIG-SEVERITY-LEVELS). Por exemplo, erros de sintaxe e cancelamentos de consulta geram uma mensagem de erro. Erros internos do servidor PostgreSQL, como erros de processo de checkpointer em segundo plano, não geram uma mensagem de erro. No entanto, os registros para esses eventos ainda são emitidos independentemente da configuração do nível de gravidade do log. Isso impede que os invasores desativem o registro em log para tentar evitar a detecção. Veja também o campo `exitCode`. | | exitCode | int | Um valor usado para um registro de saída de sessão. Em uma saída limpa, isso contém o código de saída. Um código de saída não pode ser sempre obtido em alguns cenários de falha. Exemplos são se o PostgreSQL fizer um exit() ou se um operador realizar um comando como um kill -9.Se houver algum erro, o campo `exitCode` exibirá o código de erro SQL, `SQLSTATE`, conforme listado em [PostgreSQL Error Codes](https://www.postgresql.org/docs/current/errcodes-appendix.html). Veja também o campo `errorMessage`. | | logTime | string | Um time stamp como registrado no caminho do código de auditoria. Isso representa a hora de término da execução da instrução SQL. Veja também o campo startTime. | | netProtocol | string | O protocolo de comunicação da rede | | objectName | string | O nome do objeto do banco de dados se a instrução SQL estiver operando em um. Este campo será usado somente quando a instrução SQL operar em um objeto de banco de dados. Se a instrução SQL não estiver operando em um objeto, esse valor será nulo. | | objectType | string | O tipo do objeto de banco de dados, como tabela, índice, visualização etc. Este campo será usado somente quando a instrução SQL operar em um objeto de banco de dados. Se a instrução SQL não estiver operando em um objeto, esse valor será nulo. Entre os valores válidos estão os seguintes:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) | | paramList | string | Uma matriz de parâmetros separados por vírgulas transmitidos à instrução SQL. Se a instrução SQL não tiver parâmetros, esse valor será uma matriz vazia. | | pid | int | O ID do processo de backend que está alocado para atender à conexão do cliente. | | remoteHost | string | O endereço IP do cliente ou o nome do host. No Aurora PostgreSQL, qual deles é usado depende da configuração do parâmetro log\$1hostname de banco de dados. O valor remoteHost também inclui [local] e localhost que indicam a atividade do usuário rdsadmin. | | remotePort | string | O número da porta do cliente. | | rowCount | int | O número de linhas da tabela afetadas ou recuperadas pela instrução SQL. Este campo é usado somente para instruções SQL que são instruções da linguage de manipulação de dados (DML). Se a instrução SQL não for uma instrução DML, esse valor será nulo. | | serverHost | string | O endereço IP do host do servidor do banco de dados. O valor serverHost também inclui [local] e localhost que indicam a atividade do usuário rdsadmin. | | serverType | string | O tipo de servidor do banco de dados, por exemplo PostgreSQL. | | serverVersion | string | A versão do servidor de banco de dados, por exemplo, 2.3.1 para o Aurora PostgreSQL. | | serviceName | string | O nome do serviço, por exemplo Amazon Aurora PostgreSQL-Compatible edition. | | sessionId | int | Um identificador de sessão pseudo-exclusivo. | | sessionId | int | Um identificador de sessão pseudo-exclusivo. | | startTime(somente registros de atividade de banco de dados da versão 1.1) | string | A hora em que a execução começou para a instrução SQL. Para calcular o tempo aproximado de execução da instrução SQL, use `logTime - startTime`. Veja também o campo `logTime`. | | statementId | int | Um identificador para a instrução SQL do cliente. O contador está no nível da sessão e incrementa com cada instrução SQL inserida pelo cliente. | | substatementId | int | Um identificador para uma substituição SQL. Esse valor conta as subinstruções contidas para cada instrução SQL identificada pelo campo statementId. | | type | string | O tipo de evento. Os valores válidos são record ou heartbeat. | ## Campos databaseActivityEventList para o Aurora MySQL Veja a seguir campos `databaseActivityEventList` do Aurora MySQL. | Campo | Tipo de dados | Descrição | | --- | --- | --- | | class | string | A classe do evento de atividade. Os valores válidos para o Aurora MySQL são os seguintes: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) | | clientApplication | string | O aplicativo que o cliente usou para conectar-se conforme reportado pelo cliente. O cliente não precisa fornecer essas informações, então o valor pode ser nulo. | | command | string | A categoria geral da instrução SQL. Os valores para este campo dependem do valor de `class`. Os valores quando `class` é `MAIN` incluem o seguinte: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) Os valores quando `class` é `AUX` incluem o seguinte: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) | | commandText | string | Para eventos com um valor `class` de `MAIN`, esse campo representa a instrução SQL real passada pelo usuário. Este campo é usado para todos os tipos de registros, exceto para registros de conexão ou desconexão e, nesse caso, o valor é nulo. Para eventos com um valor `class` de `AUX`, esse campo contém informações complementares sobre os objetos envolvidos no evento. No Aurora MySQL, caracteres como aspas são precedidos por uma barra invertida, representando um caractere de escape. O texto SQL completo de cada instrução é visível no log de auditoria, incluindo quaisquer dados confidenciais. No entanto, as senhas do usuário do banco de dados serão editadas se o Aurora puder determiná-las pelo contexto, como na instrução SQL a seguir. 
mysql> SET PASSWORD = 'my-password';
Especifique uma senha diferente do prompt mostrado aqui como prática recomendada de segurança. | | databaseName | string | O banco de dados ao qual o usuário se conectou. | | dbProtocol | string | o protocolo do banco de dados. Atualmente, esse valor é sempre MySQL para o Aurora MySQL. | | dbUserName | string | O usuário do banco de dados com o qual o cliente foi autenticado. | | endTime(somente registros de atividade de banco de dados da versão 1.2) | string | A hora em que a execução terminou para a instrução SQL. Ela é representada no formato de Tempo Universal Coordenado (UTC). Para calcular o tempo de execução da instrução SQL, use `endTime - startTime`. Veja também o campo `startTime`. | | errorMessage(somente registros de atividade de banco de dados da versão 1.1) | string | Se houver algum erro, esse campo será preenchido com a mensagem de erro que seria gerada pelo servidor de banco de dados. O valor `errorMessage` é nulo para instruções normais que não resultaram em um erro. Um erro é definido como qualquer atividade que produziria um evento de log de erro MySQL visível para o cliente em um nível de gravidade igual a `ERROR` ou superior. Para obter mais informações, consulte [The Error Log](https://dev.mysql.com/doc/refman/5.7/en/error-log.html) no *Guia de referência do MySQL*. Por exemplo, erros de sintaxe e cancelamentos de consulta geram uma mensagem de erro. Erros internos do servidor MySQL, como erros de processo de checkpointer em segundo plano, não geram uma mensagem de erro. No entanto, os registros para esses eventos ainda são emitidos independentemente da configuração do nível de gravidade do log. Isso impede que os invasores desativem o registro em log para tentar evitar a detecção. Veja também o campo `exitCode`. | | exitCode | int | Um valor usado para um registro de saída de sessão. Em uma saída limpa, isso contém o código de saída. Um código de saída não pode ser sempre obtido em alguns cenários de falha. Nesses casos, esse valor pode ser zero ou pode estar em branco. | | logTime | string | Um time stamp como registrado no caminho do código de auditoria. Ela é representada no formato de Tempo Universal Coordenado (UTC). Para obter a maneira mais precisa de calcular a duração da instrução, consulte os campos startTime e endTime. | | netProtocol | string | O protocolo de comunicação da rede Atualmente, esse valor é sempre TCP para o Aurora MySQL. | | objectName | string | O nome do objeto do banco de dados se a instrução SQL estiver operando em um. Este campo será usado somente quando a instrução SQL operar em um objeto de banco de dados. Se a instrução SQL não estiver operando em um objeto, esse valor estará em branco. Para construir o nome totalmente qualificado do objeto, combine databaseName e objectName. Se a consulta envolver vários objetos, esse campo pode ser uma lista de nomes separada por vírgulas. | | objectType | string | O tipo do objeto de banco de dados, como tabela, índice etc. Este campo será usado somente quando a instrução SQL operar em um objeto de banco de dados. Se a instrução SQL não estiver operando em um objeto, esse valor será nulo. Os valores válidos para o Aurora MySQL incluem o seguinte: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/AmazonRDS/latest/AuroraUserGuide/DBActivityStreams.AuditLog.databaseActivityEventList.html) | | paramList | string | Este campo não é usado para o Aurora MySQL e é sempre nulo. | | pid | int | O ID do processo de backend que está alocado para atender à conexão do cliente. Quando o servidor de banco de dados é reiniciado, o pid é alterado e o contador do campo statementId recomeça a contagem. | | remoteHost | string | O endereço IP ou o nome do host do cliente que emitiu a instrução SQL. No Aurora MySQL, qual deles é usado depende da configuração do parâmetro skip\$1name\$1resolve de banco de dados. O valor localhost indica atividade do usuário especial rdsadmin. | | remotePort | string | O número da porta do cliente. | | rowCount | int | O número de linhas retornado pela instrução SQL. Por exemplo, se uma instrução SELECT retornar 10 linhas, rowCount será 10. Para instruções INSERT ou UPDATE, rowCount é 0. | | serverHost | string | O identificador da instância do servidor de banco de dados. | | serverType | string | O tipo de servidor do banco de dados, por exemplo MySQL. | | serverVersion | string | A versão do servidor do banco de dados. Atualmente, esse valor é sempre MySQL 5.7.12 para o Aurora MySQL. | | serviceName | string | O nome do serviço da Atualmente, esse valor é sempre Amazon Aurora MySQL para o Aurora MySQL. | | sessionId | int | Um identificador de sessão pseudo-exclusivo. | | startTime(somente registros de atividade de banco de dados da versão 1.1) | string | A hora em que a execução começou para a instrução SQL. Ela é representada no formato de Tempo Universal Coordenado (UTC). Para calcular o tempo de execução da instrução SQL, use `endTime - startTime`. Veja também o campo `endTime`. | | statementId | int | Um identificador para a instrução SQL do cliente. O contador incrementa com cada instrução SQL inserida pelo cliente. O contador é redefinido quando a instância de banco de dados é reiniciada. | | substatementId | int | Um identificador para uma substituição SQL. Este valor é 1 para eventos com classe MAIN e 2 para eventos com classe AUX. Use o campo statementId para identificar todos os eventos gerados pela mesma instrução. | | transactionId(somente registros de atividade de banco de dados da versão 1.2) | int | Um identificador para uma transação. | | type | string | O tipo de evento. Os valores válidos são record ou heartbeat. | # Processar um fluxo de atividade usando o SDK da AWS É possível processar de maneira programática um fluxo de atividade usando o SDK da AWS. Veja a seguir exemplos de Java e Python em total funcionamento de como você pode processar o fluxo de dados do Kinesis. ------ #### [ Java ] ``` import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.net.InetAddress; import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; import java.security.NoSuchAlgorithmException; import java.security.NoSuchProviderException; import java.security.Security; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.UUID; import java.util.zip.GZIPInputStream; import javax.crypto.Cipher; import javax.crypto.NoSuchPaddingException; import javax.crypto.spec.SecretKeySpec; import com.amazonaws.auth.AWSStaticCredentialsProvider; import com.amazonaws.auth.BasicAWSCredentials; import com.amazonaws.encryptionsdk.AwsCrypto; import com.amazonaws.encryptionsdk.CryptoInputStream; import com.amazonaws.encryptionsdk.jce.JceMasterKey; import com.amazonaws.services.kinesis.clientlibrary.exceptions.InvalidStateException; import com.amazonaws.services.kinesis.clientlibrary.exceptions.ShutdownException; import com.amazonaws.services.kinesis.clientlibrary.exceptions.ThrottlingException; import com.amazonaws.services.kinesis.clientlibrary.interfaces.IRecordProcessor; import com.amazonaws.services.kinesis.clientlibrary.interfaces.IRecordProcessorCheckpointer; import com.amazonaws.services.kinesis.clientlibrary.interfaces.IRecordProcessorFactory; import com.amazonaws.services.kinesis.clientlibrary.lib.worker.InitialPositionInStream; import com.amazonaws.services.kinesis.clientlibrary.lib.worker.KinesisClientLibConfiguration; import com.amazonaws.services.kinesis.clientlibrary.lib.worker.ShutdownReason; import com.amazonaws.services.kinesis.clientlibrary.lib.worker.Worker; import com.amazonaws.services.kinesis.clientlibrary.lib.worker.Worker.Builder; import com.amazonaws.services.kinesis.model.Record; import com.amazonaws.services.kms.AWSKMS; import com.amazonaws.services.kms.AWSKMSClientBuilder; import com.amazonaws.services.kms.model.DecryptRequest; import com.amazonaws.services.kms.model.DecryptResult; import com.amazonaws.util.Base64; import com.amazonaws.util.IOUtils; import com.google.gson.Gson; import com.google.gson.GsonBuilder; import com.google.gson.annotations.SerializedName; import org.bouncycastle.jce.provider.BouncyCastleProvider; public class DemoConsumer { private static final String STREAM_NAME = "aws-rds-das-[cluster-external-resource-id]"; private static final String APPLICATION_NAME = "AnyApplication"; //unique application name for dynamo table generation that holds kinesis shard tracking private static final String AWS_ACCESS_KEY = "[AWS_ACCESS_KEY_TO_ACCESS_KINESIS]"; private static final String AWS_SECRET_KEY = "[AWS_SECRET_KEY_TO_ACCESS_KINESIS]"; private static final String DBC_RESOURCE_ID = "[cluster-external-resource-id]"; private static final String REGION_NAME = "[region-name]"; //us-east-1, us-east-2... private static final BasicAWSCredentials CREDENTIALS = new BasicAWSCredentials(AWS_ACCESS_KEY, AWS_SECRET_KEY); private static final AWSStaticCredentialsProvider CREDENTIALS_PROVIDER = new AWSStaticCredentialsProvider(CREDENTIALS); private static final AwsCrypto CRYPTO = new AwsCrypto(); private static final AWSKMS KMS = AWSKMSClientBuilder.standard() .withRegion(REGION_NAME) .withCredentials(CREDENTIALS_PROVIDER).build(); class Activity { String type; String version; String databaseActivityEvents; String key; } class ActivityEvent { @SerializedName("class") String _class; String clientApplication; String command; String commandText; String databaseName; String dbProtocol; String dbUserName; String endTime; String errorMessage; String exitCode; String logTime; String netProtocol; String objectName; String objectType; List paramList; String pid; String remoteHost; String remotePort; String rowCount; String serverHost; String serverType; String serverVersion; String serviceName; String sessionId; String startTime; String statementId; String substatementId; String transactionId; String type; } class ActivityRecords { String type; String clusterId; String instanceId; List databaseActivityEventList; } static class RecordProcessorFactory implements IRecordProcessorFactory { @Override public IRecordProcessor createProcessor() { return new RecordProcessor(); } } static class RecordProcessor implements IRecordProcessor { private static final long BACKOFF_TIME_IN_MILLIS = 3000L; private static final int PROCESSING_RETRIES_MAX = 10; private static final long CHECKPOINT_INTERVAL_MILLIS = 60000L; private static final Gson GSON = new GsonBuilder().serializeNulls().create(); private static final Cipher CIPHER; static { Security.insertProviderAt(new BouncyCastleProvider(), 1); try { CIPHER = Cipher.getInstance("AES/GCM/NoPadding", "BC"); } catch (NoSuchAlgorithmException | NoSuchPaddingException | NoSuchProviderException e) { throw new ExceptionInInitializerError(e); } } private long nextCheckpointTimeInMillis; @Override public void initialize(String shardId) { } @Override public void processRecords(final List records, final IRecordProcessorCheckpointer checkpointer) { for (final Record record : records) { processSingleBlob(record.getData()); } if (System.currentTimeMillis() > nextCheckpointTimeInMillis) { checkpoint(checkpointer); nextCheckpointTimeInMillis = System.currentTimeMillis() + CHECKPOINT_INTERVAL_MILLIS; } } @Override public void shutdown(IRecordProcessorCheckpointer checkpointer, ShutdownReason reason) { if (reason == ShutdownReason.TERMINATE) { checkpoint(checkpointer); } } private void processSingleBlob(final ByteBuffer bytes) { try { // JSON $Activity final Activity activity = GSON.fromJson(new String(bytes.array(), StandardCharsets.UTF_8), Activity.class); // Base64.Decode final byte[] decoded = Base64.decode(activity.databaseActivityEvents); final byte[] decodedDataKey = Base64.decode(activity.key); Map context = new HashMap<>(); context.put("aws:rds:dbc-id", DBC_RESOURCE_ID); // Decrypt final DecryptRequest decryptRequest = new DecryptRequest() .withCiphertextBlob(ByteBuffer.wrap(decodedDataKey)).withEncryptionContext(context); final DecryptResult decryptResult = KMS.decrypt(decryptRequest); final byte[] decrypted = decrypt(decoded, getByteArray(decryptResult.getPlaintext())); // GZip Decompress final byte[] decompressed = decompress(decrypted); // JSON $ActivityRecords final ActivityRecords activityRecords = GSON.fromJson(new String(decompressed, StandardCharsets.UTF_8), ActivityRecords.class); // Iterate throught $ActivityEvents for (final ActivityEvent event : activityRecords.databaseActivityEventList) { System.out.println(GSON.toJson(event)); } } catch (Exception e) { // Handle error. e.printStackTrace(); } } private static byte[] decompress(final byte[] src) throws IOException { ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(src); GZIPInputStream gzipInputStream = new GZIPInputStream(byteArrayInputStream); return IOUtils.toByteArray(gzipInputStream); } private void checkpoint(IRecordProcessorCheckpointer checkpointer) { for (int i = 0; i < PROCESSING_RETRIES_MAX; i++) { try { checkpointer.checkpoint(); break; } catch (ShutdownException se) { // Ignore checkpoint if the processor instance has been shutdown (fail over). System.out.println("Caught shutdown exception, skipping checkpoint." + se); break; } catch (ThrottlingException e) { // Backoff and re-attempt checkpoint upon transient failures if (i >= (PROCESSING_RETRIES_MAX - 1)) { System.out.println("Checkpoint failed after " + (i + 1) + "attempts." + e); break; } else { System.out.println("Transient issue when checkpointing - attempt " + (i + 1) + " of " + PROCESSING_RETRIES_MAX + e); } } catch (InvalidStateException e) { // This indicates an issue with the DynamoDB table (check for table, provisioned IOPS). System.out.println("Cannot save checkpoint to the DynamoDB table used by the Amazon Kinesis Client Library." + e); break; } try { Thread.sleep(BACKOFF_TIME_IN_MILLIS); } catch (InterruptedException e) { System.out.println("Interrupted sleep" + e); } } } } private static byte[] decrypt(final byte[] decoded, final byte[] decodedDataKey) throws IOException { // Create a JCE master key provider using the random key and an AES-GCM encryption algorithm final JceMasterKey masterKey = JceMasterKey.getInstance(new SecretKeySpec(decodedDataKey, "AES"), "BC", "DataKey", "AES/GCM/NoPadding"); try (final CryptoInputStream decryptingStream = CRYPTO.createDecryptingStream(masterKey, new ByteArrayInputStream(decoded)); final ByteArrayOutputStream out = new ByteArrayOutputStream()) { IOUtils.copy(decryptingStream, out); return out.toByteArray(); } } public static void main(String[] args) throws Exception { final String workerId = InetAddress.getLocalHost().getCanonicalHostName() + ":" + UUID.randomUUID(); final KinesisClientLibConfiguration kinesisClientLibConfiguration = new KinesisClientLibConfiguration(APPLICATION_NAME, STREAM_NAME, CREDENTIALS_PROVIDER, workerId); kinesisClientLibConfiguration.withInitialPositionInStream(InitialPositionInStream.LATEST); kinesisClientLibConfiguration.withRegionName(REGION_NAME); final Worker worker = new Builder() .recordProcessorFactory(new RecordProcessorFactory()) .config(kinesisClientLibConfiguration) .build(); System.out.printf("Running %s to process stream %s as worker %s...\n", APPLICATION_NAME, STREAM_NAME, workerId); try { worker.run(); } catch (Throwable t) { System.err.println("Caught throwable while processing data."); t.printStackTrace(); System.exit(1); } System.exit(0); } private static byte[] getByteArray(final ByteBuffer b) { byte[] byteArray = new byte[b.remaining()]; b.get(byteArray); return byteArray; } } ``` ------ #### [ Python ] ``` import base64 import json import zlib import aws_encryption_sdk from aws_encryption_sdk import CommitmentPolicy from aws_encryption_sdk.internal.crypto import WrappingKey from aws_encryption_sdk.key_providers.raw import RawMasterKeyProvider from aws_encryption_sdk.identifiers import WrappingAlgorithm, EncryptionKeyType import boto3 REGION_NAME = '' # us-east-1 RESOURCE_ID = '' # cluster-ABCD123456 STREAM_NAME = 'aws-rds-das-' + RESOURCE_ID # aws-rds-das-cluster-ABCD123456 enc_client = aws_encryption_sdk.EncryptionSDKClient(commitment_policy=CommitmentPolicy.FORBID_ENCRYPT_ALLOW_DECRYPT) class MyRawMasterKeyProvider(RawMasterKeyProvider): provider_id = "BC" def __new__(cls, *args, **kwargs): obj = super(RawMasterKeyProvider, cls).__new__(cls) return obj def __init__(self, plain_key): RawMasterKeyProvider.__init__(self) self.wrapping_key = WrappingKey(wrapping_algorithm=WrappingAlgorithm.AES_256_GCM_IV12_TAG16_NO_PADDING, wrapping_key=plain_key, wrapping_key_type=EncryptionKeyType.SYMMETRIC) def _get_raw_key(self, key_id): return self.wrapping_key def decrypt_payload(payload, data_key): my_key_provider = MyRawMasterKeyProvider(data_key) my_key_provider.add_master_key("DataKey") decrypted_plaintext, header = enc_client.decrypt( source=payload, materials_manager=aws_encryption_sdk.materials_managers.default.DefaultCryptoMaterialsManager(master_key_provider=my_key_provider)) return decrypted_plaintext def decrypt_decompress(payload, key): decrypted = decrypt_payload(payload, key) return zlib.decompress(decrypted, zlib.MAX_WBITS + 16) def main(): session = boto3.session.Session() kms = session.client('kms', region_name=REGION_NAME) kinesis = session.client('kinesis', region_name=REGION_NAME) response = kinesis.describe_stream(StreamName=STREAM_NAME) shard_iters = [] for shard in response['StreamDescription']['Shards']: shard_iter_response = kinesis.get_shard_iterator(StreamName=STREAM_NAME, ShardId=shard['ShardId'], ShardIteratorType='LATEST') shard_iters.append(shard_iter_response['ShardIterator']) while len(shard_iters) > 0: next_shard_iters = [] for shard_iter in shard_iters: response = kinesis.get_records(ShardIterator=shard_iter, Limit=10000) for record in response['Records']: record_data = record['Data'] record_data = json.loads(record_data) payload_decoded = base64.b64decode(record_data['databaseActivityEvents']) data_key_decoded = base64.b64decode(record_data['key']) data_key_decrypt_result = kms.decrypt(CiphertextBlob=data_key_decoded, EncryptionContext={'aws:rds:dbc-id': RESOURCE_ID}) print (decrypt_decompress(payload_decoded, data_key_decrypt_result['Plaintext'])) if 'NextShardIterator' in response: next_shard_iters.append(response['NextShardIterator']) shard_iters = next_shard_iters if __name__ == '__main__': main() ``` ------ # Exemplos de políticas do IAM para fluxos de atividades de banco de dados Qualquer usuário com privilégios de função do AWS Identity and Access Management (IAM) para os fluxos de atividades de banco de dados pode criar, iniciar, interromper e modificar as configurações do fluxo de atividade para um cluster de banco de dados. Essas ações estão incluídas no log de auditoria do fluxo. Para realizar as práticas recomendadas de conformidade, recomendamos não fornecer esses privilégios a DBAs. Você define o acesso aos fluxos de atividades de banco de dados usando políticas do IAM. Para obter mais informações sobre autenticação do Aurora, consulte [Gerenciamento de identidade e acesso no Amazon Aurora](UsingWithRDS.IAM.md). Para obter mais informações sobre como criar políticas do IAM, consulte [Criar e usar uma política do IAM para acesso do banco de dados do IAM](UsingWithRDS.IAMDBAuth.IAMPolicy.md). **Example Política para permitir a configuração de fluxos de atividades de banco de dados** Para conceder aos usuários acesso refinado para modificar fluxos de atividade, use as chaves de contexto de operação específicas de serviço `rds:StartActivityStream` e `rds:StopActivityStream` em uma política do IAM. O exemplo de política do IAM a seguir permite que um usuário ou uma função configure fluxos de atividade. **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "ConfigureActivityStreams", "Effect": "Allow", "Action": [ "rds:StartActivityStream", "rds:StopActivityStream" ], "Resource": "*" } ] } ``` **Example Política para permitir o início de fluxos de atividades de banco de dados** O exemplo de política do IAM a seguir permite que um usuário ou uma função inicie fluxos de atividade. **** ``` { "Version":"2012-10-17", "Statement":[ { "Sid":"AllowStartActivityStreams", "Effect":"Allow", "Action":"rds:StartActivityStream", "Resource":"*" } ] } ``` **Example Política para permitir a interrupção de fluxos de atividades de banco de dados** O exemplo de política do IAM a seguir permite que um usuário ou uma função interrompa fluxos de atividade. **** ``` { "Version":"2012-10-17", "Statement":[ { "Sid":"AllowStopActivityStreams", "Effect":"Allow", "Action":"rds:StopActivityStream", "Resource":"*" } ] } ``` **Example Política para negar o início de fluxos de atividades de banco de dados** O exemplo de política do IAM a seguir impede que um usuário ou uma função inicie fluxos de atividades. **** ``` { "Version":"2012-10-17", "Statement":[ { "Sid":"DenyStartActivityStreams", "Effect":"Deny", "Action":"rds:StartActivityStream", "Resource":"*" } ] } ``` **Example Política para interromper o início de fluxos de atividades de banco de dados** O exemplo de política do IAM a seguir impede que um usuário ou uma função interrompa fluxos de atividades. **** ``` { "Version":"2012-10-17", "Statement":[ { "Sid":"DenyStopActivityStreams", "Effect":"Deny", "Action":"rds:StopActivityStream", "Resource":"*" } ] } ```