

AWS App Runner não estará mais aberto a novos clientes a partir de 30 de abril de 2026. Se você quiser usar o App Runner, inscreva-se antes dessa data. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [Mudança de disponibilidade do AWS App Runner](https://docs.aws.amazon.com/apprunner/latest/dg/apprunner-availability-change.html).

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Observabilidade para seu serviço App Runner
<a name="monitor"></a>

AWS App Runner se integra a vários AWS serviços para fornecer um amplo conjunto de ferramentas de observabilidade para seu serviço App Runner. Os tópicos deste capítulo descrevem esses recursos.

**Topics**
+ [Rastreando a atividade do serviço App Runner](monitor-activity.md)
+ [Visualizando registros do App Runner transmitidos para o Logs CloudWatch](monitor-cwl.md)
+ [Visualizando as métricas de serviço do App Runner reportadas para CloudWatch](monitor-cw.md)
+ [Gerenciando eventos do App Runner em EventBridge](monitor-ev.md)
+ [Registrando chamadas da API App Runner com AWS CloudTrail](monitor-ct.md)
+ [Rastreamento para seu aplicativo App Runner com X-Ray](monitor-xray.md)

# Rastreando a atividade do serviço App Runner
<a name="monitor-activity"></a>

AWS App Runner usa uma lista de operações para acompanhar as atividades em seu serviço App Runner. Uma operação representa uma chamada assíncrona para uma ação de API, como criar um serviço, atualizar uma configuração e implantar um serviço. As seções a seguir mostram como monitorar a atividade no console do App Runner e usar a API.

## Rastreie a atividade do serviço App Runner
<a name="monitor-activity.monitor"></a>

Monitore a atividade do serviço App Runner usando um dos seguintes métodos:

------
#### [ App Runner console ]

O console do App Runner exibe sua atividade de serviço do App Runner e fornece mais maneiras de explorar as operações.

**Para visualizar a atividade do seu serviço**

1. Abra o [console do App Runner](https://console.aws.amazon.com/apprunner) e, na lista **Regiões**, selecione seu Região da AWS.

1. No painel de navegação, escolha **Serviços** e, em seguida, escolha seu serviço App Runner.

   O console exibe o painel do serviço com uma **visão geral do serviço**.  
![\[Página do painel do serviço App Runner mostrando a lista de atividades\]](http://docs.aws.amazon.com/pt_br/apprunner/latest/dg/images/console-dashboard.png)

1. Na página do painel do serviço, escolha a guia **Atividade**, se ela ainda não tiver sido escolhida.

   O console exibe uma lista de operações.

1. Para encontrar operações específicas, examine a lista inserindo um termo de pesquisa. Você pode pesquisar qualquer valor que apareça na tabela.

1. Escolha qualquer operação listada para ver ou baixar o registro relacionado.

------
#### [ App Runner API or AWS CLI ]

A [ListOperations](https://docs.aws.amazon.com/apprunner/latest/api/API_ListOperations.html)ação, dada o Amazon Resource Name (ARN) de um serviço App Runner, retorna uma lista das operações que ocorreram nesse serviço. Cada item da lista contém um ID de operação e alguns detalhes de rastreamento.

------

# Visualizando registros do App Runner transmitidos para o Logs CloudWatch
<a name="monitor-cwl"></a>

Você pode usar o Amazon CloudWatch Logs para monitorar, armazenar e acessar arquivos de log gerados por seus recursos em vários AWS serviços. Para obter mais informações, consulte o [Guia do usuário do Amazon CloudWatch Logs](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/).

AWS App Runner coleta a saída das implantações do seu aplicativo e do seu serviço ativo e a transmite para o Logs. CloudWatch As seções a seguir listam os fluxos de log do App Runner e mostram como visualizá-los no console do App Runner.

## Grupos e streams de registros do App Runner
<a name="monitor-cwl.streams"></a>

CloudWatch Os registros mantêm os dados de registro em fluxos de registro que são organizados posteriormente em grupos de registros. Um *fluxo de log* é uma sequência de eventos de log de uma fonte específica. Um *grupo de logs* é um grupo de fluxos de log que compartilham as mesmas configurações de retenção, monitoramento e controle de acesso.

O App Runner define dois grupos de CloudWatch registros de registros, cada um com vários fluxos de registros, para cada serviço do App Runner em seu. Conta da AWS

### Registros de serviço
<a name="monitor-cwl.streams.service"></a>

O grupo de registros de serviço contém a saída de registro gerada pelo App Runner à medida que ele gerencia seu serviço App Runner e age sobre ele.


|  **Nome do grupo de logs**  |  **Exemplo**  | 
| --- | --- | 
|  `/aws/apprunner/service-name/service-id/service`  |  `/aws/apprunner/python-test/ac7ec8b51ff34746bcb6654e0bcb23da/service`  | 

Dentro do grupo de registros de serviços, o App Runner cria um fluxo de registros de eventos para capturar atividades no ciclo de vida do seu serviço App Runner. Por exemplo, isso pode ser iniciar seu aplicativo ou pausá-lo.

Além disso, o App Runner cria um fluxo de log para cada operação assíncrona de longa duração relacionada ao seu serviço. O nome do fluxo de log reflete o tipo de operação e o ID específico da operação.

Uma *implantação* é um tipo de operação. Os registros de implantação contêm a saída de registro das etapas de criação e implantação que o App Runner executa quando você cria um serviço ou implanta uma nova versão do seu aplicativo. Os nomes do fluxo de log de implantação começam com `deployment/` e terminam com o ID da operação que executa a implantação. Essa operação é uma [CreateService](https://docs.aws.amazon.com/apprunner/latest/api/API_CreateService.html)chamada para a implantação inicial do aplicativo ou uma [StartDeployment](https://docs.aws.amazon.com/apprunner/latest/api/API_StartDeployment.html)chamada para cada implantação posterior.

Em um log de implantação, cada mensagem de log começa com um prefixo:
+ `[AppRunner]`— Saída que o App Runner gera durante a implantação.
+ `[Build]`— Saída de seus próprios scripts de construção.


|  **Nome do fluxo de logs**  |  **Exemplo**  | 
| --- | --- | 
|  `events`  |  *N/A (nome fixo)*  | 
|  `operation-type/operation-id`  |  `deployment/c2c8eeedea164f459cf78f12a8953390`  | 

### Logs de aplicações
<a name="monitor-cwl.streams.deployment"></a>

O grupo de registros do aplicativo contém a saída do código do aplicativo em execução.


|  **Nome do grupo de logs**  |  **Exemplo**  | 
| --- | --- | 
|  `/aws/apprunner/service-name/service-id/application`  |  `/aws/apprunner/python-test/ac7ec8b51ff34746bcb6654e0bcb23da/application`  | 

Dentro do grupo de registros do aplicativo, o App Runner cria um fluxo de registros para cada instância (unidade de escalabilidade) que está executando seu aplicativo.


|  **Nome do fluxo de logs**  |  **Exemplo**  | 
| --- | --- | 
|  `instance/instance-id`  |  `instance/1a80bc9134a84699b7b3432ebeebb591`  | 

## Visualizando os registros do App Runner no console
<a name="monitor-cwl.console"></a>

O console do App Runner exibe um resumo de todos os registros do seu serviço e permite que você os visualize, explore e baixe.

**Para ver os registros do seu serviço**

1. Abra o [console do App Runner](https://console.aws.amazon.com/apprunner) e, na lista **Regiões**, selecione seu Região da AWS.

1. No painel de navegação, escolha **Serviços** e, em seguida, escolha seu serviço App Runner.

   O console exibe o painel do serviço com uma **visão geral do serviço**.  
![\[Página do painel do serviço App Runner mostrando a lista de atividades\]](http://docs.aws.amazon.com/pt_br/apprunner/latest/dg/images/console-dashboard.png)

1. Na página do painel do serviço, escolha a guia **Registros**.

   O console exibe alguns tipos de registros em várias seções:
   + **Registro de eventos** — Atividade no ciclo de vida do seu serviço App Runner. O console exibe os eventos mais recentes.
   + **Registros de implantação** — forneça implantações de repositórios para seu serviço App Runner. O console exibe um fluxo de log separado para cada implantação.
   + **Registros do aplicativo** — A saída do aplicativo web que é implantado no seu serviço App Runner. O console combina a saída de todas as instâncias em execução em um único fluxo de registros.  
![\[A guia Registros na página do painel do serviço App Runner\]](http://docs.aws.amazon.com/pt_br/apprunner/latest/dg/images/service-dashboad-logs.png)

1. Para encontrar implantações específicas, examine a lista de registros de implantação inserindo um termo de pesquisa. Você pode pesquisar qualquer valor que apareça na tabela.

1. Para visualizar o conteúdo de um registro, escolha **Exibir registro completo (registro** de eventos) ou o nome do fluxo de registros (registros de implantação e aplicativos).

1. Escolha **Baixar** para baixar um registro. Para um fluxo de registros de implantação, selecione primeiro um fluxo de registros.

1. Escolha **Visualizar em CloudWatch** para abrir o CloudWatch console e usar seus recursos completos para explorar seus registros de serviço do App Runner. Para um fluxo de registros de implantação, selecione primeiro um fluxo de registros.
**nota**  
O CloudWatch console é particularmente útil se você quiser visualizar os registros do aplicativo de instâncias específicas em vez do registro combinado do aplicativo.

# Visualizando as métricas de serviço do App Runner reportadas para CloudWatch
<a name="monitor-cw"></a>

A Amazon CloudWatch monitora seus recursos da Amazon Web Services (AWS) e os aplicativos em que você executa AWS em tempo real. Você pode usar CloudWatch para coletar e monitorar métricas, que são variáveis que você pode medir para seus recursos e aplicativos. Você também pode usá-lo para criar alarmes que monitorem as métricas. Quando um determinado limite é atingido, CloudWatch envia notificações ou faz alterações automaticamente nos recursos monitorados. Para obter mais informações, consulte o [Guia CloudWatch do usuário da Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).

AWS App Runner coleta uma variedade de métricas que fornecem maior visibilidade sobre o uso, o desempenho e a disponibilidade dos seus serviços do App Runner. Algumas métricas rastreiam instâncias individuais que executam seu serviço web, enquanto outras estão no nível geral do serviço. As seções a seguir listam as métricas do App Runner e mostram como visualizá-las no console do App Runner. 

## Métricas do App Runner
<a name="monitor-cw.metrics"></a>

O App Runner coleta as seguintes métricas relacionadas ao seu serviço e as publica CloudWatch no namespace. `AWS/AppRunner`

**nota**  
*Antes de 23 de agosto de 2023, as métricas de **utilização da CPU** e da **memória** eram baseadas em unidades de vCPU e megabytes de memória utilizados, em vez da porcentagem de utilização, conforme calculado hoje.* Se seu aplicativo foi executado no App Runner antes dessa data e você optar por voltar a ver as métricas dessa data no App Runner ou no CloudWatch console, você verá uma exibição das métricas em ambas as unidades e também verá algumas irregularidades como resultado. 

**Importante**  
Você precisará atualizar todos CloudWatch os alarmes baseados nos valores da métrica de *utilização da CPU e da* *memória* antes de 23 de agosto de 2023. Atualize os alarmes para serem acionados com base na porcentagem de utilização, em vez de vCPU ou megabytes. Para obter mais informações, consulte o [Guia CloudWatch do usuário da Amazon](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/).

As **métricas em nível de instância** são coletadas para cada instância (unidade de escalabilidade) individualmente.


|  **O que é medido?**  |  **Métrica**  |  **Descrição**  | 
| --- | --- | --- | 
|  CPU utilization  |  `CPUUtilization`  |  A porcentagem do uso médio da CPU durante períodos de um minuto do uso total da CPU reservado pela configuração do serviço.  | 
|  Memory utilization  |  `MemoryUtilization`  |  A porcentagem do uso médio de memória durante períodos de um minuto do total de memória reservada pela configuração do serviço.  | 

**As métricas de nível de serviço** são coletadas para todo o serviço.


|  **O que é medido?**  |  **Métrica**  |  **Descrição**  | 
| --- | --- | --- | 
|  CPU utilization  |  `CPUUtilization`  |  A porcentagem do uso agregado da CPU em todas as instâncias durante períodos de um minuto do uso total da CPU reservado pela configuração do serviço.  | 
|  Memory utilization  |  `MemoryUtilization`  |  A porcentagem de uso de memória agregada em todas as instâncias durante períodos de um minuto do total de memória reservada pela configuração do serviço.  | 
|  Concurrency  |  `Concurrency`  |  O número aproximado de solicitações simultâneas que estão sendo tratadas pelo serviço.  | 
|  HTTP request count  |  `Requests`  |  O número de solicitações HTTP que o serviço recebeu.  | 
|  HTTP status counts  |  `2xxStatusResponses` `4xxStatusResponses` `5xxStatusResponses`  |  O número de solicitações HTTP que retornaram cada status de resposta, agrupadas por categoria (2XX, 4XX, 5XX).  | 
|  HTTP request latency  |  `RequestLatency`  |  O tempo, em milissegundos, que seu serviço web levou para processar solicitações HTTP.  | 
|  Instance counts  |  `ActiveInstances`  |  O número de instâncias que estão processando solicitações HTTP para seu serviço.   Se a `ActiveInstances` métrica exibir zero, isso significa que não há solicitações para o serviço. Isso não indica que o número de instâncias do seu serviço seja zero.    | 

## Visualizando métricas do App Runner no console
<a name="monitor-cw.console"></a>

O console do App Runner exibe graficamente as métricas que o App Runner coleta para seu serviço e fornece mais maneiras de explorá-las.

**nota**  
No momento, o console exibe somente métricas de serviço. Para ver as métricas da instância, use o CloudWatch console.

**Para ver os registros do seu serviço**

1. Abra o [console do App Runner](https://console.aws.amazon.com/apprunner) e, na lista **Regiões**, selecione seu Região da AWS.

1. No painel de navegação, escolha **Serviços** e, em seguida, escolha seu serviço App Runner.

   O console exibe o painel do serviço com uma **visão geral do serviço**.  
![\[Página do painel do serviço App Runner mostrando a lista de atividades\]](http://docs.aws.amazon.com/pt_br/apprunner/latest/dg/images/console-dashboard.png)

1. Na página do painel do serviço, escolha a guia **Métricas**.

   O console exibe um conjunto de gráficos de métricas.   
![\[A guia Métricas na página do painel do serviço App Runner\]](http://docs.aws.amazon.com/pt_br/apprunner/latest/dg/images/service-dashboad-metrics.png)

1. Escolha uma duração (por exemplo, **12h**) para definir gráficos de métricas para o período recente dessa duração.

1. Escolha **Adicionar ao painel** na parte superior de uma das seções do gráfico ou use o menu em qualquer gráfico para adicionar as métricas relevantes a um painel no CloudWatch console para uma investigação mais aprofundada.

# Gerenciando eventos do App Runner em EventBridge
<a name="monitor-ev"></a>

Usando a Amazon EventBridge, você pode configurar regras orientadas por eventos que monitoram um fluxo de dados em tempo real do seu AWS App Runner serviço para determinados padrões. Quando um padrão para uma regra é correspondido, EventBridge inicia uma ação em um destino, como AWS Lambda Amazon ECS e Amazon SNS. AWS Batch Por exemplo, você pode definir uma regra para enviar notificações por e-mail sinalizando um tópico do Amazon SNS sempre que uma implantação do seu serviço falhar. Ou você pode definir uma função Lambda para notificar um canal do Slack sempre que uma atualização de serviço falhar. Para obter mais informações sobre EventBridge, consulte o [Guia EventBridge do usuário da Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/).

O App Runner envia os seguintes tipos de eventos para EventBridge
+ *Alteração do status do serviço* — Uma alteração no status de um serviço do App Runner. Por exemplo, o status de um serviço foi alterado para`DELETE_FAILED`.
+ *Alteração do status da operação do serviço* — Uma alteração no status de uma operação longa e assíncrona em um serviço do App Runner. Por exemplo, um serviço começou a ser criado, uma atualização de serviço foi concluída com êxito ou uma implantação de serviço foi concluída com erros.

## Criação de uma EventBridge regra para agir em eventos do App Runner
<a name="monitor-ev.rule"></a>

Um EventBridge *evento* é um objeto que define alguns EventBridge campos padrão, como o AWS serviço de origem e o tipo de detalhe (evento), e um conjunto de campos específico do evento com os detalhes do evento. Para criar uma EventBridge regra, você usa o EventBridge console para definir um *padrão de evento* (quais eventos devem ser rastreados) e especificar uma *ação alvo* (o que deve ser feito em uma partida). Um padrão de evento é semelhante aos eventos aos quais ele corresponde. Você especifica um subconjunto de campos para corresponder e, para cada campo, especifica uma lista de valores possíveis. Este tópico fornece exemplos de eventos e padrões de eventos do App Runner.

Para obter mais informações sobre a criação de EventBridge regras, consulte [Criação de uma regra para um AWS serviço](https://docs.aws.amazon.com/eventbridge/latest/userguide/create-eventbridge-rule.html) no *Guia EventBridge do usuário da Amazon*.

**nota**  
Alguns serviços oferecem suporte a *padrões predefinidos* em EventBridge. Isso simplifica a forma como um padrão de evento é criado. Você seleciona valores de campo em um formulário e EventBridge gera o padrão para você. No momento, o App Runner não oferece suporte a padrões predefinidos. Você precisa inserir o padrão como um objeto JSON. Você pode usar os exemplos deste tópico como ponto de partida.

## Exemplos de eventos do App Runner
<a name="monitor-ev.event-examples"></a>

Estes são alguns exemplos de eventos para os quais o App Runner envia. EventBridge
+ Um evento de alteração do status do serviço. Especificamente, um serviço que mudou do `OPERATION_IN_PROGRESS` para o `RUNNING` status.

  ```
  { 
    "version": "0",
    "id": "6a7e8feb-b491-4cf7-a9f1-bf3703467718",
    "detail-type": "AppRunner Service Status Change",
    "source": "aws.apprunner",
    "account": "111122223333",
    "time": "2021-04-29T11:54:23Z",
    "region": "us-east-2",
    "resources": [
      "arn:aws:apprunner:us-east-2:123456789012:service/my-app/8fe1e10304f84fd2b0df550fe98a71fa"
    ],
    "detail": {
      "previousServiceStatus": "OPERATION_IN_PROGRESS",
      "currentServiceStatus": "RUNNING",
      "serviceName": "my-app",
      "serviceId": "8fe1e10304f84fd2b0df550fe98a71fa",
      "message": "Service status is set to RUNNING.",
      "severity": "INFO"
    }
  }
  ```
+ Um evento de alteração do status da operação. Especificamente, uma `UpdateService` operação concluída com êxito.

  ```
  { 
    "version": "0",
    "id": "6a7e8feb-b491-4cf7-a9f1-bf3703467718",
    "detail-type": "AppRunner Service Operation Status Change",
    "source": "aws.apprunner",
    "account": "111122223333",
    "time": "2021-04-29T18:43:48Z",
    "region": "us-east-2",
    "resources": [
      "arn:aws:apprunner:us-east-2:123456789012:service/my-app/8fe1e10304f84fd2b0df550fe98a71fa"
    ],
    "detail": {
      "operationStatus": "UpdateServiceCompletedSuccessfully",
      "serviceName": "my-app",
      "serviceId": "8fe1e10304f84fd2b0df550fe98a71fa",
      "message": "Service update completed successfully. New application and configuration is deployed.",
      "severity": "INFO"
    }
  }
  ```

## Exemplos de padrões de eventos do App Runner
<a name="monitor-ev.pattern-examples"></a>

Os exemplos a seguir demonstram padrões de eventos que você pode usar em EventBridge regras para corresponder a um ou mais eventos do App Runner. Um padrão de evento é semelhante a um evento. Inclua somente os campos que você deseja combinar e forneça uma lista em vez de um escalar para cada um.
+ Combine todos os eventos de alteração de status do serviço para serviços de uma conta específica, em que o serviço não está mais no `RUNNING` status.

  ```
  { 
    "detail-type": [ "AppRunner Service Status Change" ],
    "source": [ "aws.apprunner" ],
    "account": [ "111122223333" ],
    "detail": {
      "previousServiceStatus": [ "RUNNING" ]
    }
  }
  ```
+ Combine todos os eventos de alteração do status da operação para serviços de uma conta específica em que a operação falhou.

  ```
  { 
    "detail-type": [ "AppRunner Service Operation Status Change" ],
    "source": [ "aws.apprunner" ],
    "account": [ "111122223333" ],
    "detail": {
      "operationStatus": [
        "CreateServiceFailed",
        "DeleteServiceFailed",
        "UpdateServiceFailed",
        "DeploymentFailed",
        "PauseServiceFailed",
        "ResumeServiceFailed"
      ]
    }
  }
  ```

## Referência do evento App Runner
<a name="monitor-ev.ref"></a>

### Alteração do status do serviço
<a name="monitor-ev.ref.service"></a>

Um evento de alteração do status do serviço foi `detail-type` definido como`AppRunner Service Status Change`. Ele tem os seguintes campos e valores de detalhes:

```
"serviceId": "your service ID",
"serviceName": "your service name",
"message": "Service status is set to CurrentStatus.",
"previousServiceStatus": "any valid service status",
"currentServiceStatus": "any valid service status",
"severity": "varies"
```

### Alteração do status da operação
<a name="monitor-ev.ref.operation"></a>

Um evento de alteração do status da operação foi `detail-type` definido como`AppRunner Service Operation Status Change`. Ele tem os seguintes campos e valores de detalhes:

```
"operationStatus": "see following table",
"serviceName": "your service name",
"serviceId": "your service ID",
"message": "see following table",
"severity": "varies"
```

A tabela a seguir lista todos os códigos de status possíveis e mensagens relacionadas.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/apprunner/latest/dg/monitor-ev.html)

# Registrando chamadas da API App Runner com AWS CloudTrail
<a name="monitor-ct"></a>

O App Runner é integrado com AWS CloudTrail, um serviço que fornece um registro das ações realizadas por um usuário, função ou AWS serviço no App Runner. CloudTrailcaptura todas as chamadas de API para o App Runner como eventos. As chamadas capturadas incluem chamadas do console do App Runner e chamadas de código para as operações da API do App Runner. Se você criar uma trilha, poderá habilitar a entrega contínua de CloudTrail eventos para um bucket do Amazon S3, incluindo eventos para o App Runner. Se você não configurar uma trilha, ainda poderá ver os eventos mais recentes no CloudTrail console no **Histórico de eventos**. Usando as informações coletadas por CloudTrail, você pode determinar a solicitação que foi feita ao App Runner, o endereço IP de onde a solicitação foi feita, quem fez a solicitação, quando ela foi feita e detalhes adicionais. 

Para saber mais sobre isso CloudTrail, consulte o [Guia AWS CloudTrail do usuário](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).

## Informações sobre o App Runner em CloudTrail
<a name="apprunner-info-in-cloudtrail"></a>

CloudTrail é ativado no seu Conta da AWS quando você cria a conta. Quando a atividade ocorre no App Runner, essa atividade é registrada em um CloudTrail evento junto com outros eventos de AWS serviço no **histórico** de eventos. Você pode visualizar, pesquisar e baixar eventos recentes no seu Conta da AWS. Para obter mais informações, consulte [Visualização de eventos com histórico de CloudTrail eventos](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html). 

Para um registro contínuo dos eventos em seu Conta da AWS, incluindo eventos do App Runner, crie uma trilha. Uma *trilha* permite CloudTrail entregar arquivos de log para um bucket do Amazon S3. Por padrão, quando você cria uma trilha no console, ela é aplicada a todas as Regiões da AWS. A trilha registra eventos de todas as regiões na AWS partição e entrega os arquivos de log ao bucket do Amazon S3 que você especificar. Além disso, você pode configurar outros AWS serviços para analisar e agir com base nos dados de eventos coletados nos CloudTrail registros. Para saber mais, consulte: 
+ [Visão Geral para Criar uma Trilha](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail Serviços e integrações compatíveis](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Configurando notificações do Amazon SNS para CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html)
+ [Recebendo arquivos de CloudTrail log de várias regiões](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) e [recebendo arquivos de CloudTrail log de várias contas](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)

Todas as ações do App Runner são registradas CloudTrail e documentadas na Referência da AWS App Runner API. Por exemplo, chamadas para as `StartDeployment` ações `CreateService``DeleteConnection`, e geram entradas nos arquivos de CloudTrail log. 

Cada entrada de log ou evento contém informações sobre quem gerou a solicitação. As informações de identidade ajudam a determinar: 
+ Se a solicitação foi feita com credenciais de usuário-raiz ou usuário do IAM.
+ Se a solicitação foi feita com credenciais de segurança temporárias de um perfil ou de um usuário federado.
+ Se a solicitação foi feita por outro AWS serviço.

Para obter mais informações, consulte [Elemento userIdentity do CloudTrail ](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).

## Entendendo as entradas do arquivo de log do App Runner
<a name="understanding-apprunner-entries"></a>

Uma trilha é uma configuração que permite a entrega de eventos como arquivos de log para um bucket do Amazon S3 que você especificar. CloudTrail os arquivos de log contêm uma ou mais entradas de log. Um evento representa uma única solicitação de qualquer fonte e inclui informações sobre a ação solicitada, a data e a hora da ação e os parâmetros da solicitação. CloudTrail os arquivos de log não são um rastreamento de pilha ordenado das chamadas públicas de API, portanto, eles não aparecem em nenhuma ordem específica. 

O exemplo a seguir mostra uma entrada de CloudTrail registro que demonstra a `CreateService` ação.

**nota**  
Por motivos de segurança, alguns valores de propriedades são editados nos registros e substituídos pelo texto`HIDDEN_DUE_TO_SECURITY_REASONS`. Isso evita a exposição não intencional de informações secretas. No entanto, você ainda pode ver que essas propriedades foram passadas na solicitação ou retornadas na resposta.

### Exemplo de entrada de CloudTrail registro para a ação `CreateService` App Runner
<a name="understanding-apprunner-entries.example"></a>

```
{
  "eventVersion": "1.08",
  "userIdentity": {
    "type": "IAMUser",
    "principalId": "AIDACKCEVSQ6C2EXAMPLE",
    "arn": "arn:aws:iam::123456789012:user/aws-user",
    "accountId": "123456789012",
    "accessKeyId": "AKIAIOSFODNN7EXAMPLE",
    "userName": "aws-user"
  },
  "eventTime": "2020-10-02T23:25:33Z",
  "eventSource": "apprunner.amazonaws.com",
  "eventName": "CreateService",
  "awsRegion": "us-east-2",
  "sourceIPAddress": "192.0.2.0",
  "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.75 Safari/537.36",
  "requestParameters": {
    "serviceName": "python-test",
    "sourceConfiguration": {
      "codeRepository": {
        "repositoryUrl": "https://github.com/github-user/python-hello",
        "sourceCodeVersion": {
          "type": "BRANCH",
          "value": "main"
        },
        "codeConfiguration": {
          "configurationSource": "API",
          "codeConfigurationValues": {
            "runtime": "python3",
            "buildCommand": "HIDDEN_DUE_TO_SECURITY_REASONS",
            "startCommand": "HIDDEN_DUE_TO_SECURITY_REASONS",
            "port": "8080",
            "runtimeEnvironmentVariables": "HIDDEN_DUE_TO_SECURITY_REASONS"
          }
        }
      },
      "autoDeploymentsEnabled": true,
      "authenticationConfiguration": {
        "connectionArn": "arn:aws:apprunner:us-east-2:123456789012:connection/your-connection/e7656250f67242d7819feade6800f59e"
      }
    },
    "healthCheckConfiguration": {
      "protocol": "HTTP"
    },
    "instanceConfiguration": {
      "cpu": "256",
      "memory": "1024"
    }
  },
  "responseElements": {
    "service": {
        "serviceName": "python-test",
        "serviceId": "dfa2b7cc7bcb4b6fa6c1f0f4efff988a",
        "serviceArn": "arn:aws:apprunner:us-east-2:123456789012:service/python-test/dfa2b7cc7bcb4b6fa6c1f0f4efff988a",
        "serviceUrl": "generated domain",
        "createdAt": "2020-10-02T23:25:32.650Z",
        "updatedAt": "2020-10-02T23:25:32.650Z",
        "status": "OPERATION_IN_PROGRESS",
        "sourceConfiguration": {
            "codeRepository": {
                "repositoryUrl": "https://github.com/github-user/python-hello",
                "sourceCodeVersion": {
                    "type": "Branch",
                    "value": "main"
                },
                "sourceDirectory": "/",
                "codeConfiguration": {
                    "codeConfigurationValues": {
                        "configurationSource": "API",
                        "runtime": "python3",
                        "buildCommand": "HIDDEN_DUE_TO_SECURITY_REASONS",
                        "startCommand": "HIDDEN_DUE_TO_SECURITY_REASONS",
                        "port": "8080",
                        "runtimeEnvironmentVariables": "HIDDEN_DUE_TO_SECURITY_REASONS"
                    }
                }
            },
            "autoDeploymentsEnabled": true,
            "authenticationConfiguration": {
                "connectionArn": "arn:aws:apprunner:us-east-2:123456789012:connection/your-connection/e7656250f67242d7819feade6800f59e"
            }
        },
        "healthCheckConfiguration": {
            "protocol": "HTTP",
            "path": "/",
            "interval": 5,
            "timeout": 2,
            "healthyThreshold": 3,
            "unhealthyThreshold": 5
        },
        "instanceConfiguration": {
            "cpu": "256",
            "memory": "1024"
        },
        "autoScalingConfigurationSummary": {
            "autoScalingConfigurationArn": "arn:aws:apprunner:us-east-2:123456789012:autoscalingconfiguration/DefaultConfiguration/1/00000000000000000000000000000001",
            "autoScalingConfigurationName": "DefaultConfiguration",
            "autoScalingConfigurationRevision": 1
        }
    }
},
  "requestID": "1a60af60-ecf5-4280-aa8f-64538319ba0a",
  "eventID": "e1a3f623-4d24-4390-a70b-bf08a0e24669",
  "readOnly": false,
  "eventType": "AwsApiCall",
  "recipientAccountId": "123456789012"
}
```

# Rastreamento para seu aplicativo App Runner com X-Ray
<a name="monitor-xray"></a>

AWS X-Ray é um serviço que coleta dados sobre solicitações atendidas pelo seu aplicativo e fornece ferramentas que você pode usar para visualizar, filtrar e obter informações sobre esses dados para identificar problemas e oportunidades de otimização. Para qualquer solicitação rastreada para seu aplicativo, você pode ver informações detalhadas não apenas sobre a solicitação e a resposta, mas também sobre as chamadas que seu aplicativo faz para AWS recursos downstream, microsserviços, bancos de dados e web HTTP. APIs

O X-Ray usa dados de rastreamento dos AWS recursos que alimentam seus aplicativos em nuvem para gerar um gráfico de serviço detalhado. O gráfico de serviço mostra o cliente, o serviço front-end e os serviços back-end chamados pelo serviço front-end para processar solicitações e manter dados. Use o gráfico de serviço para identificar gargalos, picos de latência e outros problemas a fim de resolver o desempenho dos aplicativos.

Para obter mais informações sobre o X-Ray, consulte o [Guia do desenvolvedor do AWS X-Ray](https://docs.aws.amazon.com/xray/latest/devguide/).

![\[Um exemplo de um mapa de serviço X-Ray para um serviço App Runner\]](http://docs.aws.amazon.com/pt_br/apprunner/latest/dg/images/xray-example.png)


## Instrumente seu aplicativo para rastreamento
<a name="monitor-xray.instrument"></a>

Instrumente seu aplicativo de serviço App Runner para rastreamento usando [OpenTelemetry](https://github.com/open-telemetry)uma especificação de telemetria portátil. No momento, o App Runner oferece suporte à [AWS Distro for OpenTelemetry](https://aws-otel.github.io/docs/introduction) (ADOT), uma OpenTelemetry implementação que coleta e apresenta informações de telemetria usando serviços. AWS X-Ray implementa o componente de rastreamento.

**Dependendo do SDK ADOT específico que você usa em seu aplicativo, o ADOT suporta até duas abordagens de instrumentação: automática e manual.** Para obter mais informações sobre instrumentação com seu SDK, consulte a [documentação do ADOT](https://aws-otel.github.io/docs/introduction) e escolha seu SDK no painel de navegação.

### Configuração de tempo de execução
<a name="monitor-xray.instrument.setup"></a>

 A seguir estão as instruções gerais de configuração do tempo de execução para instrumentar seu aplicativo de serviço App Runner para rastreamento. 

**Para configurar o rastreamento para seu tempo de execução**

1.  Siga as instruções fornecidas para seu tempo de execução no [AWS Distro for OpenTelemetry](https://aws-otel.github.io/docs/introduction) (ADOT), para instrumentar seu aplicativo. 

1.  Instale as `OTEL` dependências necessárias na `build` seção do `apprunner.yaml` arquivo se você estiver usando o repositório de código-fonte ou no Dockerfile se estiver usando uma imagem de contêiner. 

1.  Configure suas variáveis de ambiente no `apprunner.yaml` arquivo se você estiver usando o repositório de código-fonte ou no Dockerfile se estiver usando uma imagem de contêiner.   
**Example Variáveis de ambiente**  
**nota**  
O exemplo a seguir lista as variáveis de ambiente importantes a serem adicionadas ao `apprunner.yaml` arquivo. Adicione essas variáveis de ambiente ao seu Dockerfile se você estiver usando uma imagem de contêiner. No entanto, cada tempo de execução pode ter suas próprias idiossincrasias e talvez seja necessário adicionar mais variáveis de ambiente à lista a seguir. Para obter mais informações sobre instruções específicas de seu tempo de execução e exemplos sobre como configurar seu aplicativo para seu tempo de execução, consulte [AWS Distro for OpenTelemetry](https://aws-otel.github.io/docs/introduction) and go your runtime, em *Getting Started*. 

   ```
   env:
       - name: OTEL_PROPAGATORS
         value: xray
       - name: OTEL_METRICS_EXPORTER
         value: none
       - name: OTEL_EXPORTER_OTLP_ENDPOINT
         value: http://localhost:4317  
       - name: OTEL_RESOURCE_ATTRIBUTES
         value: 'service.name=example_app'
   ```
**nota**  
 `OTEL_METRICS_EXPORTER=none`é uma variável de ambiente importante para o App Runner, pois o coletor App Runner Otel não aceita o registro de métricas. Ele só aceita rastreamento de métricas. 

### Exemplo de configuração de tempo de execução
<a name="monitor-xray.instrument.example"></a>

[O exemplo a seguir demonstra a instrumentação automática de seu aplicativo com o SDK ADOT Python.](https://aws-otel.github.io/docs/getting-started/python-sdk) O SDK produz automaticamente extensões com dados de telemetria que descrevem os valores usados pelas estruturas Python em seu aplicativo sem adicionar uma única linha de código Python. Você precisa adicionar ou modificar apenas algumas linhas em dois arquivos de origem.

Primeiro, adicione algumas dependências, conforme mostrado no exemplo a seguir.

**Example requirements.txt**  

```
opentelemetry-distro[otlp]>=0.24b0
opentelemetry-sdk-extension-aws~=2.0
opentelemetry-propagator-aws-xray~=1.0
```

Em seguida, instrumente seu aplicativo. A forma de fazer isso depende da fonte do serviço: imagem fonte ou código-fonte.

------
#### [ Source image ]

Quando sua fonte de serviço é uma imagem, você pode instrumentar diretamente o Dockerfile que controla a criação da imagem do contêiner e a execução do aplicativo na imagem. O exemplo a seguir mostra um Dockerfile instrumentado para um aplicativo Python. As adições de instrumentação são enfatizadas em negrito.

**Example Dockerfile**  

```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest
RUN yum install python3.7 -y && curl -O https://bootstrap.pypa.io/get-pip.py && python3 get-pip.py && yum update -y
COPY . /app
WORKDIR /app
RUN pip3 install -r requirements.txt
RUN opentelemetry-bootstrap --action=install
ENV OTEL_PYTHON_DISABLED_INSTRUMENTATIONS=urllib3
ENV OTEL_METRICS_EXPORTER=none              
ENV OTEL_RESOURCE_ATTRIBUTES='service.name=example_app'
CMD OTEL_PROPAGATORS=xray OTEL_PYTHON_ID_GENERATOR=xray opentelemetry-instrument python3 app.py
EXPOSE 8080
```

------
#### [ Source code repository ]

Quando sua fonte de serviço é um repositório contendo a fonte do aplicativo, você instrumenta indiretamente sua imagem usando as configurações do arquivo de configuração do App Runner. Essas configurações controlam o Dockerfile que o App Runner gera e usa para criar a imagem para seu aplicativo. O exemplo a seguir mostra um arquivo de configuração instrumentado do App Runner para um aplicativo Python. As adições de instrumentação são enfatizadas em negrito.

**Example apprunner.yaml**  

```
version: 1.0
runtime: python3 
build:
  commands:
    build:
      - pip install -r requirements.txt
      - opentelemetry-bootstrap --action=install
run: 
  command: opentelemetry-instrument python app.py
  network: 
    port: 8080 
  env:
    - name: OTEL_PROPAGATORS
      value: xray
    - name: OTEL_METRICS_EXPORTER
      value: none
    - name: OTEL_PYTHON_ID_GENERATOR
      value: xray  
    - name: OTEL_PYTHON_DISABLED_INSTRUMENTATIONS 
      value: urllib3
    - name: OTEL_RESOURCE_ATTRIBUTES
      value: 'service.name=example_app'
```

------

## Adicione permissões X-Ray à sua função de instância de serviço App Runner
<a name="monitor-xray.role"></a>

Para usar o rastreamento X-Ray com seu serviço App Runner, você precisa fornecer às instâncias do serviço permissões para interagir com o serviço X-Ray. Você faz isso associando uma função de instância ao seu serviço e adicionando uma política gerenciada com permissões X-Ray. Para obter mais informações sobre uma função de instância do App Runner, consulte[Perfil da instância](security_iam_service-with-iam.md#security_iam_service-with-iam-roles-service.instance). Adicione a política `AWSXRayDaemonWriteAccess` gerenciada à sua função de instância e atribua-a ao seu serviço durante a criação.

## Ative o rastreamento X-Ray para seu serviço App Runner
<a name="monitor-xray.config"></a>

Quando você [cria um serviço](manage-create.md), o App Runner desativa o rastreamento por padrão. Você pode ativar o rastreamento X-Ray para seu serviço como parte da configuração da observabilidade. Para obter mais informações, consulte [Gerencie a observabilidade](manage-configure-observability.md#manage-configure-observability.manage).

Se você usa a API App Runner ou a AWS CLI, o [TraceConfiguration](https://docs.aws.amazon.com/apprunner/latest/api/API_TraceConfiguration.html)objeto dentro do objeto de [ObservabilityConfiguration](https://docs.aws.amazon.com/apprunner/latest/api/API_ObservabilityConfiguration.html)recurso contém configurações de rastreamento. Para manter o rastreamento desativado, não especifique um `TraceConfiguration` objeto.

Nos casos do console e da API, não se esqueça de associar sua função de instância discutida na seção anterior ao seu serviço App Runner.

## Visualize os dados de rastreamento do X-Ray para seu serviço App Runner
<a name="monitor-xray.view"></a>

Na guia **Observabilidade** da [página do painel de serviços](console.md#console.dashboard) no console do App Runner, escolha **Exibir mapa do serviço** para navegar até o console da Amazon CloudWatch .

![\[Página do painel do serviço App Runner mostrando a guia de observabilidade\]](http://docs.aws.amazon.com/pt_br/apprunner/latest/dg/images/service-dashboad-observability.png)


Use o CloudWatch console da Amazon para visualizar mapas e rastreamentos de serviços para solicitações atendidas pelo seu aplicativo. Os mapas de serviços mostram informações como latência da solicitação e interações com outros aplicativos e AWS serviços. As anotações personalizadas que você adiciona ao seu código permitem que você pesquise facilmente por rastreamentos. Para obter mais informações, consulte [Usando ServiceLens para monitorar a integridade de seus aplicativos](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ServiceLens.html) no *Guia do CloudWatch usuário da Amazon*.