Gravação e reprodução da sessão

A gravação e a reprodução da sessão do navegador fornecem uma observabilidade abrangente para fins de depuração, auditoria ou treinamento. Quando você cria um navegador com a gravação de sessão ativada, o Amazon Bedrock captura AgentCore automaticamente as interações do navegador e as armazena em seu bucket Amazon S3 especificado para análise posterior.

A repetição da sessão captura dados abrangentes de interação do navegador que permitem que você visualize as repetições e compreenda as ações que ocorreram durante as sessões do navegador. Essa funcionalidade ajuda você a resolver erros e melhorar futuras invocações, fornecendo informações detalhadas sobre o comportamento do navegador.

As informações coletadas durante a repetição da sessão incluem:

Pré-requisitos para gravação da sessão

Para ativar a gravação da sessão, você precisa:

Configurar a função do IAM para gravação

Para habilitar a gravação da sessão, você precisa de uma função de execução do IAM com permissões para gravar dados de gravação no Amazon S3 e registrar atividades no. CloudWatch Para obter instruções detalhadas sobre como configurar permissões, consulte Permissões.

A função de execução exige permissões adicionais além das permissões padrão do navegador:

{
    "Sid": "S3Permissions",
    "Effect": "Allow",
    "Action": [
        "s3:PutObject",
        "s3:GetObject",
        "s3:ListBucket",
        "s3:ListMultipartUploadParts",
        "s3:AbortMultipartUpload"
    ],
    "Resource": [
        "arn:aws:s3:::your-recording-bucket",
        "arn:aws:s3:::your-recording-bucket/*"
    ]
},
{
    "Sid": "CloudWatchLogsPermissions",
    "Effect": "Allow",
    "Action": [
        "logs:CreateLogGroup",
        "logs:CreateLogStream",
        "logs:PutLogEvents",
        "logs:DescribeLogStreams"
    ],
    "Resource": "*"
}

your-recording-bucketSubstitua pelo nome real do bucket do Amazon S3.

Etapa 1: Crie uma ferramenta de navegador com gravação

Crie uma ferramenta de navegador personalizada com a gravação ativada. Para obter instruções detalhadas sobre como criar ferramentas de navegador, consulte Criação de um AgentCore navegador.

Ao criar sua ferramenta de navegador, certifique-se de:

Exemplo usando o SDK do Python:

import boto3
import uuid

region = "us-west-2"
bucket = "your-recording-bucket"

client = boto3.client("bedrock-agentcore-control", region_name=region)

response = client.create_browser(
    name="MyRecordingBrowser",
    description="Browser with session recording enabled",
    networkConfiguration={"networkMode": "PUBLIC"},
    executionRoleArn="arn:aws:iam::123456789012:role/AgentCoreBrowserRecordingRole",
    clientToken=str(uuid.uuid4()),
    recording={
        "enabled": True,
        "s3Location": {
            "bucket": bucket,
            "prefix": "browser-recordings"
        }
    }
)

browser_identifier = response.get("browserId") or response.get("browserIdentifier")
print(f"Created browser with recording: {browser_identifier}")
print(f"Recordings will be stored at: s3://{bucket}/browser-recordings/")

Etapa 2: use o navegador habilitado para gravação

Use seu navegador habilitado para gravação com qualquer estrutura de automação. Todas as interações do navegador serão registradas automaticamente. Exemplo usando Strands:

from strands import Agent
from strands_tools.browser import AgentCoreBrowser

# Use the browser created with recording
browser_identifier = "your-browser-identifier"
region = "us-west-2"
browser_tool = AgentCoreBrowser(region=region, identifier=browser_identifier)

agent = Agent(tools=[browser_tool.browser])
prompt = (
    "Navigate to https://docs.aws.amazon.com/bedrock-agentcore/latest/devguide/what-is-bedrock-agentcore.html "
    "and summarize the key features of AgentCore."
)

response = agent(prompt)
print("Agent Response:")
print(response.message["content"][0]["text"])

Todas as interações durante esta sessão serão automaticamente gravadas e enviadas para o seu bucket do Amazon S3 quando a sessão terminar.

Etapa 3: monitorar sessões ao vivo e reproduzir gravações

O AWS console fornece ferramentas abrangentes para monitoramento em tempo real e análise de sessões gravadas.

Monitoramento de visualização ao vivo

Monitore as sessões do navegador em tempo real e interaja com as sessões ativas:

Para acessar a visualização ao vivo no console

A interface de visualização ao vivo fornece:

Repetição e análise da sessão

Acesse gravações e análises detalhadas da sessão por meio da interface de reprodução do console:

Para acessar a reprodução da sessão no console

Recursos de análise de sessão

O console fornece várias ferramentas de análise:

Navegue pelas gravações

Use esses métodos para navegar pelas gravações:

Etapa 4: Acesse as gravações programaticamente

Acesse a visualização ao vivo e a gravação de insights de forma programática usando o AgentCore SDK e as APIs do Amazon Bedrock para integração personalizada e análise automatizada.

Acesso programático à visualização ao vivo

Conecte-se às sessões ao vivo do navegador usando o cliente do navegador e o servidor visualizador:

import time
from rich.console import Console
from bedrock_agentcore.tools.browser_client import browser_session
from browser_viewer import BrowserViewerServer

console = Console()

def main():
    try:
        # Create browser session
        with browser_session('us-west-2') as client:
            print("✅ Browser ready!")
            ws_url, headers = client.generate_ws_headers()

            # Start viewer server
            console.print("[cyan]Starting viewer server...[/cyan]")
            viewer = BrowserViewerServer(client, port=8005)
            viewer_url = viewer.start(open_browser=True)

            # Keep running
            while True:
                time.sleep(1)

    except KeyboardInterrupt:
        console.print("[yellow]Shutting down...[/yellow]")
        if 'client' in locals():
            client.stop()
            console.print("✅ Browser session terminated")

if __name__ == "__main__":
    main()

Acesso programático à gravação

Acesse dados de gravação diretamente do Amazon S3 para fluxos de trabalho de análise personalizados:

import boto3

s3_client = boto3.client('s3', region_name='us-west-2')

# List recordings in your bucket
bucket_name = "your-recording-bucket"
prefix = "browser-recordings/"

response = s3_client.list_objects_v2(Bucket=bucket_name, Prefix=prefix)

print(f"Recordings in s3://{bucket_name}/{prefix}:")
for obj in response.get('Contents', []):
    print(f"  {obj['Key']} ({obj['Size']} bytes)")
    print(f"    Last Modified: {obj['LastModified']}")
    print()

Estrutura de dados de gravação:

s3://your-recording-bucket/browser-recordings/
  └── session-id/
      ├── batch_1.ndjson.gz
      ├── batch_2.ndjson.gz
      └── batch_3.ndjson.gz

Cada sessão cria uma pasta com o ID da sessão, e os dados de gravação são carregados em partes à medida que a sessão avança.

Exemplos programáticos de repetição de sessão

Para casos de uso avançados, você pode criar visualizadores de repetição de sessão personalizados e integrar dados de gravação em seus próprios fluxos de trabalho de análise.

Os GitHub exemplos a seguir mostram um visualizador de repetição de sessão independente e como é a experiência completa do navegador ao usar o recurso de repetição de sessão do navegador.

Para obter exemplos adicionais, consulte Exemplos de AgentCore navegadores em GitHub.

# View the latest recording in a bucket
python view_recordings.py --bucket session-record-test-123456789012 --prefix replay-data

# View a specific recording
python view_recordings.py --bucket session-record-test-123456789012 --prefix replay-data --session 01JZVDG02M8MXZY2N7P3PKDQ74

# Use a specific AWS profile
python view_recordings.py --bucket session-record-test-123456789012 --prefix replay-data --profile my-profile

# View the latest recording in a bucket
python -m live_view_sessionreplay.browser_interactive_session