Author: Make.com Service User

  • Amazon Quick ARNs: Migração Entre Contas e Permissões por Namespace

    O problema que todo administrador do Amazon Quick já enfrentou

    Você migra dashboards do ambiente de desenvolvimento para produção — e as permissões simplesmente somem. Você compartilha um painel com o time de Finanças e eles continuam recebendo “acesso negado”. Você configura namespaces para isolamento multi-tenant e o mesmo nome de usuário funciona em um namespace, mas não em outro.

    Esses são cenários reais que administradores do Amazon Quick enfrentam com frequência. Resolver esses problemas exige entender como os Nomes de Recursos da Amazon (ARNs — Amazon Resource Names) funcionam dentro do serviço. A AWS publicou um guia técnico detalhado sobre esse tema, e a CloudTroop traz aqui uma leitura comentada para o público brasileiro.

    Uma nota importante sobre nomenclatura

    O Amazon Quick é o nome atual do serviço, mas os ARNs e endpoints de API ainda utilizam quicksight como identificador de serviço. Isso foi mantido para garantir compatibilidade com políticas existentes do Serviço de Gerenciamento de Identidade e Acesso (IAM — Identity and Access Management), automações e integrações já em produção. Portanto, você continuará vendo ARNs no formato:

    arn:aws:quicksight:us-east-1:123456789012:dashboard/...

    O trecho quicksight refere-se à capacidade Quick Sight dentro do Amazon Quick. Códigos, políticas IAM e comandos de interface de linha de comando (CLI — Command Line Interface) existentes continuam funcionando sem modificação. Para mais detalhes, consulte a documentação de ARNs de Recursos do Amazon Quick Sight.

    ARNs como endereços postais

    Uma forma simples de entender ARNs: pense neles como endereços postais. Assim como “Rua Principal, 123, São Paulo, SP” identifica um local único, um ARN identifica de forma única um recurso dentro da AWS. Veja como os componentes se mapeiam:

    • aws → Partição da AWS (aws / aws-cn / aws-gov-us)
    • quicksight → O serviço dentro da partição
    • us-east-1 → Região da AWS
    • 111111111111 → ID da conta AWS
    • dashboard → Tipo de recurso
    • 04f736b4-bd1b-… → ID único do recurso

    O ponto mais importante aqui: o ID da conta faz parte do endereço. Se você muda de conta, o endereço muda — mesmo que o ID do recurso seja idêntico. Migrar um dashboard de desenvolvimento para produção gera um ARN diferente, porque o ID da conta é diferente.

    Migração entre contas: o que muda e o que permanece

    Imagine uma empresa com três contas AWS para seu ambiente Amazon Quick: Desenvolvimento (conta 111111111111), Qualidade/Testes (conta 222222222222) e Produção (conta 333333333333).

    Uma analista cria um dashboard de vendas em Desenvolvimento:

    arn:aws:quicksight:us-east-1:111111111111:dashboard/sales-dash-001

    Ao usar as APIs de Asset Bundle para migrar para Qualidade/Testes, o dashboard recebe um novo ARN:

    arn:aws:quicksight:us-east-1:222222222222:dashboard/sales-dash-001

    O que mudou: o ID da conta (111111111111222222222222). O que permaneceu: o ID do recurso (sales-dash-001) e a região (us-east-1). O dashboard em Qualidade/Testes é um recurso diferente do original, mesmo compartilhando o mesmo ID de recurso.

    Por que permissões não migram automaticamente

    O Amazon Quick armazena permissões como relacionamentos entre ARNs de recursos e ARNs de principais (usuários ou grupos). Uma permissão concedida em Desenvolvimento diz, essencialmente: “o grupo DataAnalysts da conta 111111111111 pode visualizar este dashboard.”

    Após a migração para Qualidade/Testes, três coisas mudam:

    • O dashboard tem um novo ARN (conta diferente).
    • O grupo DataAnalysts da conta 111111111111 não existe na conta 222222222222.
    • Um grupo DataAnalysts em Qualidade/Testes teria um ARN diferente, referenciando o ID da conta de destino.

    Conclusão: permissões precisam ser reestabelecidas em cada ambiente de destino, seja durante a importação ou logo após.

    A cadeia de dependências e a transformação automática de ARNs

    Um dashboard não existe de forma isolada. Ele depende de datasets, que por sua vez dependem de fontes de dados (data sources). Cada um tem seu próprio ARN, e o dashboard referencia todos eles internamente.

    Quando as APIs de Asset Bundle importam um bundle para a conta de destino, elas atualizam automaticamente essas referências internas de ARN para refletir o novo ID de conta. Porém, essa transformação funciona apenas para os ativos incluídos no bundle. Se você importar somente o dashboard sem seus datasets e fontes de dados, ele ficará referenciando recursos que não existem na conta de destino.

    A recomendação da AWS é clara: sempre inclua todas as dependências na exportação, usando IncludeAllDependencies=True.

    Reutilizando recursos existentes com OverrideParameters

    Um cenário comum: o ambiente de Qualidade/Testes já tem uma fonte de dados configurada para o banco de dados de QA. Você não quer criar uma duplicata — quer que o dashboard importado use a conexão existente.

    O parâmetro OverrideParameters na API StartAssetBundleImportJob resolve isso. Ele permite sobrescrever parâmetros de conexão, credenciais e comportamento de IDs de recursos durante a importação:

    response = qs.start_asset_bundle_import_job(
        AwsAccountId='222222222222',
        AssetBundleImportJobId='import-sales-dash-to-qa',
        AssetBundleImportSource={'Body': bundle_bytes},
        OverrideParameters={
            'ResourceIdOverrideConfiguration': {
                'PrefixForAllResources': False
            },
            'DataSources': [{
                'DataSourceId': 'sales-db-connection',
                'DataSourceParameters': {
                    'AthenaParameters': {
                        'WorkGroup': 'qa-workgroup'
                    }
                },
                'Credentials': {
                    'CredentialPair': {
                        'Username': 'qa_service_user',
                        'Password': '{{resolve:secretsmanager:qa-db-creds:SecretString:password}}'
                    }
                }
            }]
        }
    )

    Para credenciais, há três métodos disponíveis: CredentialPair (usuário e senha), CopySourceArn (copiar de uma fonte de dados existente) ou SecretArn (referenciar diretamente um segredo no AWS Secrets Manager). A AWS recomenda o uso de SecretArn quando a organização gerencia credenciais no Secrets Manager:

    'Credentials': {
        'SecretArn': 'arn:aws:secretsmanager:us-east-1:222222222222:secret:qa-db-creds'
    }

    Namespaces: como a identidade funciona em ambientes multi-tenant

    Os namespaces do Amazon Quick oferecem isolamento multi-tenant dentro de uma única conta AWS. São amplamente usados por provedores de Software como Serviço (SaaS — Software as a Service) que embarcam analytics para múltiplos clientes, empresas com fronteiras departamentais rígidas e companhias que precisam isolar populações de usuários.

    O conceito mais importante aqui: namespaces afetam ARNs de principais (usuários e grupos), não ARNs de ativos (dashboards, datasets).

    Mesmo nome de usuário, pessoas diferentes

    Considere dois namespaces na mesma conta: HR e Marketing. Ambos têm um usuário chamado nikki_wolf:

    HR nikki_wolf:        arn:aws:quicksight:us-east-1:444444444444:user/HR/nikki_wolf
    Marketing nikki_wolf: arn:aws:quicksight:us-east-1:444444444444:user/Marketing/nikki_wolf

    São dois principais completamente diferentes. Compartilham o nome de usuário, mas seus ARNs são distintos porque o namespace é diferente. Conceder acesso a um dashboard para o nikki_wolf do HR não dá acesso ao nikki_wolf do Marketing. Sempre use o ARN completo do principal, incluindo o namespace, ao conceder ou depurar permissões.

    Ativos vivem fora dos namespaces; principais vivem dentro

    Os ARNs de ativos não contêm namespace:

    Dashboard ARN (sem namespace): arn:aws:quicksight:us-east-1:444444444444:dashboard/shared-metrics
    User ARN (com namespace):      arn:aws:quicksight:us-east-1:444444444444:user/HR/alice

    Isso é o que viabiliza o compartilhamento entre namespaces: um único dashboard pode ser compartilhado com usuários de múltiplos namespaces, desde que as permissões sejam concedidas com os ARNs completos de cada principal.

    Compartilhamento entre namespaces

    Para compartilhar um dashboard de anúncios com todos os clientes, basta conceder permissões a grupos de diferentes namespaces:

    qs.update_dashboard_permissions(
        AwsAccountId='444444444444',
        DashboardId='platform-announcements',
        GrantPermissions=[
            {
                'Principal': 'arn:aws:quicksight:us-east-1:444444444444:group/HR/Executives',
                'Actions': ['quicksight:DescribeDashboard', 'quicksight:QueryDashboard']
            },
            {
                'Principal': 'arn:aws:quicksight:us-east-1:444444444444:group/Marketing/Executives',
                'Actions': ['quicksight:DescribeDashboard', 'quicksight:QueryDashboard']
            },
            {
                'Principal': 'arn:aws:quicksight:us-east-1:444444444444:group/default/PlatformTeam',
                'Actions': ['quicksight:DescribeDashboard', 'quicksight:QueryDashboard', 'quicksight:UpdateDashboard']
            }
        ]
    )

    Permissões com wildcard por namespace

    O Amazon Quick suporta ARNs com wildcard para concessões de acesso amplas dentro de um namespace:

    arn:aws:quicksight:us-east-1:444444444444:user/HR/*

    Isso concede acesso a todos os usuários atuais e futuros do namespace HR. O wildcard se aplica apenas ao namespace especificado — usuários do Marketing não ganham acesso. Wildcards também funcionam no OverridePermissions durante a importação de asset bundles. A AWS recomenda usá-los com cuidado para permissões de escrita ou administração; para acesso somente leitura, são uma boa opção.

    Fluxo completo: migração de ponta a ponta

    Aqui está um exemplo completo combinando todos os conceitos anteriores. O cenário: uma empresa migrando sua suíte de Analytics de Vendas do ambiente de Desenvolvimento para Produção, com três dashboards, cinco datasets, duas fontes de dados (Amazon Athena e Amazon Redshift) e usuários em dois namespaces (SalesTeam e Executives).

    Passo 1: Exportar do ambiente de desenvolvimento

    export_response = qs.start_asset_bundle_export_job(
        AwsAccountId='111111111111',
        AssetBundleExportJobId='sales-analytics-export',
        ResourceArns=[
            'arn:aws:quicksight:us-east-1:111111111111:dashboard/sales-overview',
            'arn:aws:quicksight:us-east-1:111111111111:dashboard/sales-details',
            'arn:aws:quicksight:us-east-1:111111111111:dashboard/sales-trends'
        ],
        IncludeAllDependencies=True,
        ExportFormat='QUICKSIGHT_JSON'
    )

    Passo 2: Importar para produção com overrides

    import_response = qs.start_asset_bundle_import_job(
        AwsAccountId='333333333333',
        AssetBundleImportJobId='sales-analytics-import',
        AssetBundleImportSource={'Body': bundle_bytes},
        OverrideParameters={
            'ResourceIdOverrideConfiguration': {
                'PrefixForAllResources': False
            },
            'DataSources': [
                {
                    'DataSourceId': 'dev-athena-source',
                    'Name': 'Production Athena',
                    'DataSourceParameters': {
                        'AthenaParameters': {'WorkGroup': 'prod-workgroup'}
                    }
                },
                {
                    'DataSourceId': 'dev-redshift-source',
                    'Name': 'Production Redshift',
                    'DataSourceParameters': {
                        'RedshiftParameters': {
                            'Host': 'prod-cluster.xxxxx.us-east-1.redshift.amazonaws.com',
                            'Database': 'analytics',
                            'Port': 5439
                        }
                    },
                    'Credentials': {
                        'SecretArn': 'arn:aws:secretsmanager:us-east-1:333333333333:secret:prod-db-creds'
                    }
                }
            ]
        },
        OverridePermissions={
            'Dashboards': [{
                'DashboardIds': ['sales-overview', 'sales-details', 'sales-trends'],
                'Permissions': {
                    'Principals': [
                        'arn:aws:quicksight:us-east-1:333333333333:user/SalesTeam/*'
                    ],
                    'Actions': ['quicksight:DescribeDashboard', 'quicksight:QueryDashboard']
                }
            }]
        }
    )

    Usar OverridePermissions junto com OverrideParameters define as permissões durante a importação, reduzindo a janela em que recursos existem sem controles de acesso adequados.

    Passo 3: Conceder permissões granulares adicionais

    qs.update_dashboard_permissions(
        AwsAccountId='333333333333',
        DashboardId='sales-trends',
        GrantPermissions=[{
            'Principal': 'arn:aws:quicksight:us-east-1:333333333333:group/Executives/Leadership',
            'Actions': ['quicksight:DescribeDashboard', 'quicksight:QueryDashboard']
        }]
    )

    Referência rápida: formatos de ARN

    ARNs de ativos (sem namespace):

    • Dashboard: arn:aws:quicksight:{region}:{account}:dashboard/{id}
    • Analysis: arn:aws:quicksight:{region}:{account}:analysis/{id}
    • Dataset: arn:aws:quicksight:{region}:{account}:dataset/{id}
    • Data Source: arn:aws:quicksight:{region}:{account}:datasource/{id}
    • Theme: arn:aws:quicksight:{region}:{account}:theme/{id}
    • Folder: arn:aws:quicksight:{region}:{account}:folder/{id}
    • Topic: arn:aws:quicksight:{region}:{account}:topic/{id}

    ARNs de principais (com namespace):

    • Usuário: arn:aws:quicksight:{region}:{account}:user/{namespace}/{username}
    • Grupo: arn:aws:quicksight:{region}:{account}:group/{namespace}/{groupname}
    • Wildcard (todos os usuários do namespace): arn:aws:quicksight:{region}:{account}:user/{namespace}/*

    Funções utilitárias para scripts de migração

    A AWS disponibiliza funções Python para facilitar a manipulação de ARNs em scripts e pipelines de Integração e Entrega Contínua (CI/CD — Continuous Integration/Continuous Delivery):

    def parse_asset_arn(arn: str) -> dict:
        """Parse an Amazon Quick asset ARN into components."""
        parts = arn.split(':')
        resource_parts = parts[5].split('/', 1)
        return {
            'region': parts[3],
            'account_id': parts[4],
            'resource_type': resource_parts[0],
            'resource_id': resource_parts[1]
        }
    
    def parse_principal_arn(arn: str) -> dict:
        """Parse an Amazon Quick principal ARN into components."""
        parts = arn.split(':')
        resource_parts = parts[5].split('/')
        return {
            'region': parts[3],
            'account_id': parts[4],
            'principal_type': resource_parts[0],
            'namespace': resource_parts[1],
            'principal_name': resource_parts[2]
        }
    
    def transform_arn_for_account(source_arn: str, target_account: str) -> str:
        """Transform an ARN to a different account."""
        parsed = parse_asset_arn(source_arn)
        return f"arn:aws:quicksight:{parsed['region']}:{target_account}:{parsed['resource_type']}/{parsed['resource_id']}"
    
    def build_principal_arn(account: str, namespace: str, principal_type: str, name: str, region: str = 'us-east-1') -> str:
        """Build a principal ARN."""
        return f"arn:aws:quicksight:{region}:{account}:{principal_type}/{namespace}/{name}"

    Guia de troubleshooting para problemas comuns

    “Resource not found” após migração

    Sintoma: Dashboard carrega, mas exibe erros de “Dataset not found”. Causa: O dashboard referencia um ARN de dataset da conta de origem, ou as dependências não foram incluídas no bundle. Solução: Verifique se todas as dependências foram exportadas com IncludeAllDependencies=True e confirme que o job de importação foi concluído com sucesso via DescribeAssetBundleImportJob.

    “Access denied” para usuário que deveria ter acesso

    Sintoma: Usuário não consegue ver um dashboard compartilhado com ele. Diagnóstico: Verifique em qual namespace o usuário está e se o ARN do principal no grant corresponde exatamente ao ARN real do usuário:

    # Check what permissions exist
    perms = qs.describe_dashboard_permissions(
        AwsAccountId=account_id,
        DashboardId='the-dashboard'
    )
    print("Granted to:", [p['Principal'] for p in perms['Permissions']])
    
    # Check the user's actual ARN
    user = qs.describe_user(
        AwsAccountId=account_id,
        Namespace='Finance',
        UserName='nikki_wolf'
    )
    print("User ARN:", user['User']['Arn'])

    Atenção: Se o recurso estiver em uma pasta restrita, não é possível compartilhá-lo diretamente, independentemente da correção do ARN. O acesso a recursos em pastas restritas só ocorre por meio das permissões do container da hierarquia da pasta restrita.

    “Invalid principal” ao conceder permissões

    Sintoma: A API retorna erro ao tentar conceder permissões. Causa: O ARN do principal está malformado, ou o usuário/grupo não existe no namespace especificado. Solução: Verifique se o principal existe antes de conceder permissões:

    try:
        qs.describe_user(
            AwsAccountId=account_id,
            Namespace='Finance',
            UserName='nikki_wolf'
        )
        print("User exists, safe to grant permissions")
    except qs.exceptions.ResourceNotFoundException:
        print("User does not exist in this namespace")

    Os quatro pontos fundamentais sobre ARNs no Amazon Quick

    O guia da AWS resume o entendimento de ARNs no Amazon Quick em quatro conceitos-chave:

    • ARNs são vinculados à conta. Ao migrar entre contas, o endereço muda mesmo que o ID do recurso permaneça igual.
    • Permissões referenciam ARNs completos, não nomes. Conceder acesso a um usuário exige especificar conta e namespace — você sempre está concedendo a um ARN específico.
    • Ativos vivem fora dos namespaces; principais vivem dentro. Isso viabiliza o compartilhamento entre namespaces, mas exige ARNs completos de principais em toda operação.
    • O mesmo nome de usuário em namespaces diferentes representa pessoas diferentes. A migração muda ARNs mas preserva IDs de recursos; as APIs de Asset Bundle cuidam das atualizações de referências internas.

    Próximos passos

    Para começar a aplicar esses conceitos no seu ambiente, a AWS recomenda:

    Fonte

    Amazon Quick ARNs: Cross-account migration and namespace permissions (https://aws.amazon.com/blogs/machine-learning/amazon-quick-arns-cross-account-migration-and-namespace-permissions/)

  • AWS Cost Explorer ganha explicações inteligentes de custos com Amazon Q

    O que foi anunciado

    A AWS anunciou uma nova funcionalidade no Cost Explorer chamada “Analyze with Amazon Q” (Analisar com Amazon Q). Com ela, qualquer relatório configurado no Cost Explorer pode ser analisado automaticamente pela inteligência artificial do Amazon Q Developer, entregando explicações detalhadas sobre custos com apenas um clique.

    Como funciona na prática

    Antes dessa novidade, entender os custos na AWS exigia investigação manual: navegar por múltiplos filtros, cruzar dados e interpretar tendências por conta própria. Com o “Analyze with Amazon Q”, o processo ficou bem mais direto.

    O fluxo é simples: o usuário configura a visualização desejada no Cost Explorer — escolhendo filtros, serviços, períodos — e clica no botão de análise. O Amazon Q lê o contexto exato daquela tela e entrega, no painel de chat, uma explicação completa cobrindo:

    • Tendências de custo ao longo do tempo
    • Principais drivers de custo (os maiores responsáveis pelos gastos)
    • Anomalias identificadas nos dados
    • Oportunidades de otimização

    Um detalhe importante: a análise se adapta ao período selecionado. Se o usuário estiver olhando para datas passadas, o Amazon Q entrega explicações históricas. Para datas futuras, a resposta vem em formato de previsão. E para períodos mistos, o modelo cobre os dois cenários na mesma resposta.

    Conversa contínua sobre seus custos

    Além da análise inicial, o recurso permite fazer perguntas de acompanhamento diretamente no chat. O Amazon Q mantém o contexto completo da conversa, ou seja, é possível aprofundar qualquer insight sem precisar reconfigurar filtros ou recomeçar a análise do zero. Isso transforma a investigação de custos em um processo mais interativo e eficiente.

    Disponibilidade e custo

    O “Analyze with Amazon Q” já está disponível em todas as regiões comerciais da AWS e não tem custo adicional. Para experimentar, basta acessar o console do AWS Cost Explorer ou consultar o guia do usuário para mais detalhes.

    Fonte

    AWS Cost Explorer launches intelligent cost explanations powered by Amazon Q (https://aws.amazon.com/about-aws/whats-new/2026/06/aws-cost-explorer-intelligent-cost-explanations)

  • Inferência entre regiões no Amazon Bedrock: como a AWS garante flexibilidade de IA com conformidade na Europa

    O desafio de disponibilidade de modelos de IA em escala global

    Modelos de IA generativa de última geração e infraestrutura de computação acelerada estão em alta demanda global. Isso cria um desafio real para equipes que precisam garantir disponibilidade contínua de modelos em suas aplicações, sem abrir mão dos requisitos de segurança e privacidade dos dados. Para endereçar esse problema, a AWS desenvolveu o recurso de Inferência entre Regiões (CRIS — Cross-Region Inference) no Amazon Bedrock, que roteia automaticamente as requisições de inferência entre múltiplas regiões AWS dentro de fronteiras geográficas predefinidas.

    O resultado prático é que aplicações de IA generativa conseguem consumir capacidade distribuída geograficamente, tornando-se mais resilientes a picos de tráfego e indisponibilidades pontuais de modelos em regiões específicas. Neste artigo, a AWS explica como o CRIS funciona, com foco especial nos clientes europeus e nas implicações para conformidade com o Regulamento Geral de Proteção de Dados (GDPR — General Data Protection Regulation).

    O que são perfis de inferência entre regiões

    O CRIS é uma capacidade gerenciada do Amazon Bedrock que roteia requisições de inferência de modelos entre regiões AWS suportadas. Os perfis de inferência são recursos dentro do Bedrock que definem quais regiões podem receber essas requisições. Para entender como esse roteamento funciona, dois conceitos são fundamentais:

    • Região de origem (Source Region): a região a partir da qual a requisição de API é feita, especificando o perfil de inferência.
    • Região de destino (Destination Region): a região para a qual o Amazon Bedrock pode rotear a requisição a partir da origem.

    O Amazon Bedrock disponibiliza perfis de inferência definidos pelo sistema, nomeados de acordo com o modelo e as regiões geográficas que suportam. Esses perfis têm escopo global ou geográfico, e a escolha entre eles impacta diretamente as obrigações regulatórias e de conformidade de cada cliente.

    Inferência global

    Os perfis de inferência global roteiam requisições de modelos para qualquer região comercial AWS suportada. Nesse modelo, os prompts de entrada são transmitidos para uma região de destino onde o modelo é executado, e as respostas geradas são retornadas à região de origem. Todo o tráfego entre regiões é criptografado e permanece dentro da rede segura da AWS — sem passar pela internet pública.

    A região de destino é selecionada automaticamente para otimizar a capacidade disponível do modelo e minimizar a latência. Por usar todas as regiões suportadas disponíveis, aplicações que utilizam perfis globais ganham maior resiliência a eventuais gargalos de capacidade em horários de pico. Além disso, vários modelos estão disponíveis a um preço com desconto via CRIS global em comparação com invocações diretas na região ou via CRIS geográfico.

    Inferência geográfica para a União Europeia

    Os perfis de inferência geográfica (Geo CRIS) são perfis definidos pelo sistema que diferem dos globais: eles vinculam os modelos a uma geografia específica, servindo cópias do mesmo modelo a partir de diferentes regiões dentro daquele território. Para clientes europeus, a AWS criou os perfis EU CRIS, voltados especificamente para questões de residência de dados na União Europeia.

    Com o EU CRIS, todas as regiões de destino ficam dentro da União Europeia. As regras de roteamento funcionam da seguinte forma:

    • Requisições originadas de uma região dentro da UE só podem ser roteadas para outras regiões AWS também dentro da UE.
    • Regiões como Zurique e Londres não são consideradas destinos para requisições de regiões dentro da UE ao usar EU CRIS.
    • Requisições originadas de Londres só podem ser roteadas entre regiões EU disponíveis e a própria região de Londres.
    • Requisições originadas de Zurique só podem ser roteadas entre regiões EU disponíveis e a própria região de Zurique.
    • Para requisições originadas fora da UE usando EU CRIS, as otimizações consideram apenas a região de origem e as regiões da UE.

    Um detalhe importante: os perfis de inferência geográfica são estáticos. Isso significa que a AWS não adiciona novas regiões a um perfil existente. Se uma nova região de destino precisar ser incluída em um perfil geográfico, o Amazon Bedrock publicará um novo perfil com um novo identificador (ID).

    Segurança e controle no CRIS

    Para invocar modelos via CRIS, as aplicações precisam indicar explicitamente no código qual perfil de inferência será utilizado, fornecendo o ID do perfil no lugar do ID direto do modelo. O exemplo abaixo, extraído do artigo original, mostra duas invocações do modelo Amazon Nova Lite — uma usando EU CRIS e outra usando CRIS global:

    import boto3
    import json
    from botocore.exceptions import ClientError
    
    bedrock_runtime = boto3.client("bedrock-runtime", region_name="eu-south-1") # Source Region: Milan
    
    model_id = "eu.amazon.nova-2-lite-v1:0" # Amazon Nova Lite EU CRIS profile ID
    # Request can be processed within available destination Regions in EU CRIS
    response = bedrock_runtime.converse(modelId=model_id, messages=[...], additionalModelRequestFields={...})
    
    model_id = "global.amazon.nova-2-lite-v1:0" # Amazon Nova Lite Global CRIS profile ID
    # Request can be processed by any AWS Commercial Region
    response = bedrock_runtime.converse(modelId=model_id, messages=[...], additionalModelRequestFields={...})

    Do ponto de vista de controle de acesso, a AWS recomenda o uso do Gerenciamento de Identidade e Acesso da AWS (AWS IAM — Identity and Access Management) para definir quais aplicações, usuários e administradores têm permissão para invocar modelos ou perfis CRIS específicos no Amazon Bedrock. O IAM ajuda a aplicar o princípio do menor privilégio, controlando quem pode acessar dados na região de origem e evitando que conteúdos indesejados sejam incluídos nos prompts enviados às regiões de destino. O artigo Securing Amazon Bedrock cross-Region inference traz mais detalhes sobre como configurar perfis geográficos e globais com IAM.

    Transparência e auditabilidade

    Regulações de proteção de dados frequentemente exigem que os responsáveis pelo tratamento mantenham registros das atividades de processamento. Para atender a esse requisito, o Amazon Bedrock se integra a ferramentas nativas da AWS.

    Com o AWS CloudTrail, é possível monitorar continuamente a atividade da conta AWS. O CloudTrail registra o histórico de chamadas de API, incluindo chamadas feitas pelo console, SDKs e ferramentas de linha de comando. No contexto do Amazon Bedrock, os metadados de toda chamada classificada como evento de gerenciamento (management event) são registrados por padrão — incluindo APIs de invocação de modelos como Converse e InvokeModel, mas apenas os metadados, não os payloads em si. Esses logs ficam acessíveis nos últimos 90 dias no Histórico de Eventos, filtrando pela fonte bedrock.amazonaws.com. Para retenção mais longa, é possível configurar o CloudTrail para armazenar esses eventos por períodos maiores.

    Ao examinar eventos relevantes no CloudTrail, é possível identificar as regiões de origem e destino de cada invocação de modelo, com o campo inferenceRegion na seção additionalEventData indicando onde a requisição foi efetivamente processada.

    Opcionalmente, os clientes podem habilitar o Registro de Invocação de Modelos (Model Invocation Logging), que coleta informações detalhadas sobre cada chamada na região de origem da conta, incluindo a requisição completa, a resposta e os metadados. Esses logs podem ser enviados para o Amazon CloudWatch Logs ou para o Amazon Simple Storage Service (Amazon S3). Por padrão, esse recurso fica desativado e precisa ser habilitado explicitamente.

    Um ponto relevante: ao usar CRIS, o Amazon CloudWatch, o AWS CloudTrail e o Model Invocation Logging registram entradas de log somente na região de origem da conta AWS onde a requisição foi iniciada — independentemente de qual região de destino tenha processado a requisição. Isso simplifica o gerenciamento de monitoramento e mantém os requisitos de processamento local de dados.

    Como verificar os perfis CRIS disponíveis

    Para quem quiser explorar os perfis de sistema disponíveis, a AWS oferece três formas:

    • Consultar a documentação oficial, que lista todos os perfis de inferência definidos pelo sistema e as regiões de origem e destino associadas.
    • Navegar até a seção de Inferência entre Regiões no Console AWS para visualizar os perfis disponíveis a partir de uma região de origem específica.
    • Usar os SDKs da AWS, como o Boto3, conforme o exemplo abaixo:
    # pip install boto3
    import boto3
    
    region = "eu-central-1" # Frankfurt Region
    bedrock = boto3.client('bedrock', region_name=region)
    system_response = bedrock.list_inference_profiles(typeEquals='SYSTEM_DEFINED')
    #https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/bedrock/client/list_inference_profiles.html

    Conformidade com o GDPR e proteção de dados

    Muitos clientes têm requisitos de processamento local de dados e precisam de transparência sobre onde suas informações são tratadas. Isso se aplica tanto aos perfis globais quanto aos geográficos.

    A AWS destaca que clientes podem usar os serviços AWS para processar dados pessoais (conforme definição do GDPR) carregados em suas contas em conformidade com o GDPR. O Amazon Bedrock está entre os serviços no escopo do Código de Conduta de Proteção de Dados da CISPE (CISPE Data Protection Code of Conduct), que é o primeiro código pan-europeu de proteção de dados para provedores de infraestrutura em nuvem. Esse código foi aprovado pelo Comitê Europeu de Proteção de Dados (EDPB — European Data Protection Board) em maio de 2021 e formalmente adotado pela CNIL em junho de 2021.

    Tanto os perfis CRIS globais quanto os geográficos oferecem flexibilidade para que os clientes escolham a abordagem que melhor se alinha às suas obrigações regulatórias e ao seu apetite por risco. A AWS mantém uma página de Recursos de Privacidade (Privacy Features) listando os serviços que envolvem transferência de dados de clientes. Para mais informações sobre transferências de dados entre UE e EUA, a empresa disponibiliza também uma atualização para clientes sobre o EU-US Privacy Shield e posts sobre o Adendo Suplementar ao Adendo de Processamento de Dados da AWS.

    Conclusão

    O CRIS no Amazon Bedrock resolve um problema concreto: permitir que aplicações de IA generativa acessem modelos que podem não estar disponíveis em sua região primária, aumentando a resiliência a picos de tráfego e limitações regionais de capacidade — sem abrir mão de segurança, privacidade e conformidade regulatória.

    A escolha entre perfis globais e geográficos (como o EU CRIS) dá aos clientes controle sobre onde seus dados são processados, com ambas as opções alinhadas a regulações como o GDPR. Para dúvidas sobre cargas de trabalho de IA e Inferência entre Regiões, a AWS recomenda contato com o time de conta AWS. Para aprofundamento em programas de conformidade e segurança, a empresa disponibiliza o portal de Programas de Conformidade da AWS (AWS Compliance Programs).

    Fonte

    Unlocking AI flexibility in Europe: A guide to cross-region inference for EU data processing and model access (https://aws.amazon.com/blogs/machine-learning/unlocking-ai-flexibility-in-europe-a-guide-to-cross-region-inference-for-eu-data-processing-and-model-access/)

  • Pode fechar o notebook agora: hospedando agentes de código no Amazon Bedrock AgentCore

    Existe um hábito que virou rotina entre desenvolvedores que usam agentes de IA: andar de reunião em reunião com o notebook entreaberto, sentar em uma conversa individual com a tela ligada só para o agente não morrer, ou voltar para casa segurando o computador porque fechar a tampa significa encerrar a sessão do agente. O Business Insider já reportou esse comportamento. A causa é simples: agentes como Claude Code, Codex, Kiro, OpenCode, Gemini CLI e Cursor CLI precisam de cinco coisas para funcionar — um shell, um sistema de arquivos, o projeto clonado, as dependências instaladas e as permissões certas. O notebook do desenvolvedor tem tudo isso. O problema é que ele nunca foi a máquina certa para o trabalho; apenas a mais próxima.

    Imagem original — fonte: Aws

    O Amazon Bedrock AgentCore Runtime foi lançado justamente para resolver isso: cada sessão recebe um ambiente dedicado — uma microVM Linux isolada com workspace persistente, shell real e execução determinística de comandos. O que diferencia o AgentCore de produtos similares de sandbox é o ecossistema que vem junto: uma camada de Identity que faz o agente agir como o usuário que o acionou, um Gateway que expõe GitHub, Jira, Slack e serviços próprios via um único endpoint Protocolo de Contexto de Modelo (MCP), com tokens reais armazenados fora do agente, e Observability que registra cada passo do agente no Amazon CloudWatch já utilizado pela equipe.

    Por que o notebook é o host errado

    Antes de entrar nas capacidades do AgentCore, vale entender por que o notebook nunca deveria ter assumido esse papel. Quatro razões se destacam:

    • O notebook é sua zona de impacto. O agente compartilha seu shell, seu sistema de arquivos, seus tokens, sua VPN e suas chaves SSH carregadas. Um README com prompt injection malicioso é um vetor de ataque real.
    • Segredos ficam ao lado do código editado. Arquivos .env, ~/.aws/credentials, ~/.ssh/id_ed25519 e tokens de registros privados ficam acessíveis no mesmo shell que o agente usa. O princípio do menor privilégio não está sendo respeitado.
    • git worktree é uma solução parcial para paralelismo. Rodar dois agentes em paralelo com worktrees ainda significa dois processos brigando pelo mesmo host: mesmo Postgres em localhost:5432, mesmo servidor de desenvolvimento na porta :3000, mesmo keyring SSH, mesmas credenciais AWS. Três agentes em três branches equivalem a três processos em conflito numa única máquina.
    • A tampa do notebook é o interruptor de emergência. Suspender o computador suspende o agente. Fechar para uma reunião mata a sessão. Um refactor de 90 minutos ou uma migração noturna exige que a tampa fique aberta por todo esse tempo. Entregar uma funcionalidade não deveria depender do ângulo da dobradiça de um notebook.

    O que desenvolvedores e times de plataforma precisam

    Do ponto de vista do desenvolvedor, a necessidade é clara: a mesma experiência do notebook, sem as limitações. Mesmo agente, mesmo shell, mesmo sistema de arquivos, mesmo feedback imediato — mas com a possibilidade de fechar a tampa, rodar múltiplos agentes em paralelo e manter o trabalho mesmo após uma reinicialização ou um voo longo.

    Para times de plataforma, os requisitos são os de sempre: cada agente com seu próprio escopo, tráfego dentro da Nuvem Privada Virtual (VPC), identidade vinculada ao provedor de identidade (IdP) corporativo, registros no AWS CloudTrail, rastreamentos no CloudWatch, acesso a ferramentas mediado por política e credenciais que nunca ficam em disco dentro de um ambiente controlado por um Modelo de Linguagem Grande (LLM). Nada disso deveria ser opcional, e nenhum desses requisitos deveria exigir construção manual.

    Traga qualquer agente, qualquer modelo, rode em paralelo

    O AgentCore Runtime aceita Claude Code, Codex, Kiro, OpenCode, Cursor CLI, Gemini CLI ou qualquer harness próprio empacotado em container ou .zip. O container vai para o Amazon Registro de Container Elástico (ECR) ou o projeto Python / Node.js é implantado diretamente via zip. A imagem pode incluir todas as dependências necessárias: runtimes de linguagem, ferramentas de build, git e pacotes do sistema.

    O Runtime é agnóstico de modelo. O harness escolhe o modelo e o caminho para chegar até ele. Há três rotas possíveis:

    • Via Amazon Bedrock, que hospeda a família Claude da Anthropic, modelos OpenAI e outros como Nova, Llama, Mistral, Qwen e Kimi.
    • Diretamente via provedor: API da Anthropic, API da OpenAI, Google e outros ainda são acessíveis via HTTPS.
    • Via gateway LLM próprio, para quem já padronizou em uma solução interna de roteamento, fallback e controle de custos.

    A rota pelo Amazon Bedrock tem uma propriedade importante: prompts, tokens e outputs não saem da rede AWS — exatamente o que times de segurança costumam perguntar primeiro.

    Cada sessão roda em sua própria microVM Firecracker. É possível iniciar N sessões em segundos, rodar o mesmo agente contra dez branches ou colocar três agentes diferentes trabalhando no mesmo ticket e comparar quem performa melhor — sem colisões de localhost:5432, sem conflitos de filesystem.

    As quatro capacidades que transformam um container em ambiente de desenvolvimento real

    1. Workspace persistente em /mnt/workspace

    O armazenamento gerenciado de sessão (em prévia pública) oferece um diretório persistente sem configuração. O agente escreve arquivos; eles estão lá na próxima vez. node_modules, .git, caches de build, o refactor pela metade: tudo disponível exatamente como foi deixado. Quando a microVM fica ociosa, o filesystem permanece. Ao retomar com o mesmo ID de sessão, uma nova microVM monta o mesmo filesystem em milissegundos. Os dados ficam disponíveis por 14 dias de inatividade.

    client.create_agent_runtime(
        agentRuntimeName="acme-coding-agent",
        agentRuntimeArtifact={"containerConfiguration": {"containerUri": "..."}},
        filesystemConfigurations=[
            {"sessionStorage": {"mountPath": "/mnt/workspace"}}
        ],
        roleArn="arn:aws:iam::...:role/AgentExecutionRole",
    )

    No notebook, a alternativa seria usar git worktree (veja a documentação) para isolamento lógico entre sessões de agentes. No AgentCore, o isolamento é físico: cada agente aponta para uma microVM isolada com seu próprio /mnt/workspace, caches de build e estado de filesystem separados. Nenhum gerenciamento de worktree necessário.

    2. Shell interativo real

    A partir de 5 de junho, o AgentCore Runtime introduziu shells interativos para acesso terminal às sessões de agentes. O comando agentcore exec --it abre um shell com suporte a PTY direto na microVM em execução — com cores, tab completion, Ctrl+C, redimensionamento de terminal e reconexão automática em caso de queda de rede.

    Cada sessão interativa tem dois IDs relevantes: o ID de sessão do runtime (qual microVM) e o ID do shell (qual shell dentro da microVM). Passando ambos para agentcore exec --it, o desenvolvedor cai no mesmo shell, mesmo diretório de trabalho, mesmo scrollback — sem boot, sem re-clone.

    # Entrar na VM do agente
    agentcore exec --it --runtime acme-coding-agent --session-id sess-jane-1234
    
    # Reconectar ao mesmo shell depois
    agentcore exec --it --session-id sess-jane-1234 --shell-id shell-789

    3. Execução determinística de comandos pela camada de aplicação

    O terminal não é a única forma de controlar o ambiente. Para operações já determinísticas — rodar a suíte de testes, fazer push de uma branch, instalar uma dependência, buscar um dataset — é possível pular o modelo completamente. O InvokeAgentRuntimeCommand envia comandos shell direto para a microVM, transmitindo stdout/stderr de volta via HTTP/2. Sem gasto de tokens, sem decisão probabilística sobre se o push aconteceu.

    # Execução não-interativa
    agentcore exec --runtime acme-coding-agent --session-id sess-jane-1234 \
      "cd /mnt/workspace && npm test"

    4. Filesystems próprios para skills, caches e artefatos compartilhados

    O armazenamento gerenciado de sessão cobre a persistência por sessão. Para dados compartilhados entre sessões e agentes — biblioteca de Skills da equipe, cache de dependências, artefatos de pipelines anteriores — é possível montar Amazon Serviço de Armazenamento Simples (S3) Files ou pontos de acesso do Amazon Sistema de Arquivos Elástico (EFS) como diretórios POSIX dentro de cada sessão. Até cinco montagens por runtime, sem sidecars, helpers ou /etc/fstab.

    filesystemConfigurations=[
        {"sessionStorage": {"mountPath": "/mnt/workspace"}},
        {"s3FilesAccessPoint": {"accessPointArn": "...", "mountPath": "/mnt/skills"}},
        {"efsAccessPoint": {"accessPointArn": "...", "mountPath": "/mnt/cache"}},
    ]

    Ferramentas e credenciais do jeito certo

    Um agente de código que só edita arquivos tem vida curta. Em algum momento ele precisa abrir um pull request, comentar em um ticket do Jira, fazer push em um registro privado ou notificar alguém no Slack. A abordagem errada é colocar credenciais do GitHub (ou qualquer token de acesso) dentro do ~/.netrc da microVM. A abordagem certa é nunca colocá-las lá.

    O AgentCore Gateway é onde o catálogo de ferramentas fica, e o AgentCore Identity guarda as credenciais por trás: segredos de longa duração no AWS Secrets Manager, tokens de curta duração cacheados no Token Vault. As ferramentas que um agente de código precisa (GitHub, Jira, Slack, sistema de build, serviços próprios via OpenAPI ou AWS Lambda) são registradas uma vez, e o Gateway expõe um único endpoint MCP que Claude Code, Codex, Cursor, Kiro e OpenCode já utilizam. A configuração no harness é uma linha de MCP config:

    # Claude Code
    claude mcp add agentcore \
      https://<gateway-id>.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp \
      --transport http
    
    # Codex CLI
    ~/.codex/config.toml
    [mcp_servers.agentcore]
    url = "https://<gateway-id>.gateway.bedrock-agentcore.us-west-2.amazonaws.com/mcp"

    Três padrões cobrem a maioria dos fluxos de trabalho de coding:

    • Padrão bot: para agentes agindo por conta própria. Um bot do GitHub é criado, um token de acesso pessoal (PAT) com escopo fino é registrado como credencial no Gateway. O Identity guarda o PAT no Token Vault e o Gateway o anexa a cada chamada.
    • Padrão on-behalf-of: para agentes agindo como uma pessoa. O desenvolvedor faz login via IdP. O Identity gera um token de acesso de workload e o troca por um com escopo GitHub usando OAuth 2.0 Token Exchange (RFC 8693). PRs são atribuídos ao humano, não a um bot compartilhado. O mesmo fluxo funciona para Jira, Slack, Salesforce ou Confluence.
    • Padrão broker: para casos que exigem controle total do fluxo de credenciais — como tokens de instalação de GitHub App que precisam de JWT auto-assinado, ou serviços que não federam com o IdP. O target do Gateway aponta para uma Lambda que gera ou busca a credencial por chamada, faz proxy da requisição e nunca retorna o segredo ao agente.

    Uma operação que o servidor MCP do GitHub não consegue fazer é clonar um repositório privado. O clone inicial ainda passa pelo git, que precisa de uma credencial na sessão. A recomendação da AWS é manter essa credencial com escopo mínimo — um PAT read-only nos repos permitidos ou uma deploy key vinculada a um repo. O valor fica no Secrets Manager por trás de um provedor de credenciais do Identity, e no início da sessão o runtime busca o valor, usa uma vez para o git clone, e todas as ações seguintes no GitHub fluem pelo Gateway.

    Para operações de shell que falam direto com a internet — npm install, git clone, cargo build, pip install — o Gateway não vê esse tráfego. A rede subjacente sim. Agentes hospedados no AgentCore Runtime podem viver dentro da VPC, o que significa que a equipe decide o que “internet” significa a partir de dentro da microVM: resolução de DNS para registros internos, regras de security group que bloqueiam pushes para repositórios não autorizados no nível TCP, e AWS Network Firewall com allowlist de domínios na frente do gateway NAT. Para saber mais sobre controle de domínios, a AWS publicou um guia: Controle quais domínios seus agentes de IA podem acessar.

    Observabilidade, ciclo de vida e rede

    Toda invocação cai no AWS CloudTrail. Cada sessão envia rastreamentos OpenTelemetry para o Amazon CloudWatch, com métricas integradas de contagem de sessões, latência, duração, uso de tokens e taxas de erro — visíveis no dashboard CloudWatch GenAI Observability. Para ferramentas que não falam OTel nativamente, como o Claude Code, é possível incluir o coletor AWS Distro for OpenTelemetry (ADOT) como sidecar no container.

    Cada microVM pode rodar por até 8 horas, ou apenas um minuto. Quando uma sessão fica ociosa além do idleRuntimeSessionTimeout (15 minutos por padrão, configurável), o compute encerra sozinho. Para encerrar antes, o StopRuntimeSession termina a microVM imediatamente. Em ambos os casos, /mnt/workspace, S3 Files e EFS permanecem onde estão. O modelo de cobrança rastreia o consumo real de CPU (I/O wait não tem custo adicional) e o pico de memória utilizado. É possível rodar centenas de sessões em paralelo e pagar apenas pelos recursos que cada uma realmente consome.

    Quem já está usando

    Várias equipes já rodam agentes de código e outros tipos de agentes no AgentCore. A Thomson Reuters usa o AgentCore para hospedar o CoCounsel, seu assistente de IA para fluxos jurídicos de alto risco, construído sobre o Claude Agent SDK — a mesma base do Claude Code. A empresa cita a infraestrutura escalável e segura como o que permite ao time focar na construção de sistemas de IA confiáveis para clientes.

    A Iberdrola roda workloads LangGraph para operações de TI dentro de sua VPC, com Runtime, Identity, Memory e gateways MCP. A Cox Automotive foi de zero experiência com agentes a produção em um mês, rodando 17 agentes com permissões gerenciadas pelo Identity. A Druva coordena de oito a dez agentes especializados em cibersegurança no Runtime, com o Identity delimitando o escopo de cada agente (dados, ajuda, ação) sem frear o time de desenvolvimento. A Kollab hospeda seu workspace de IA no AgentCore Runtime, com o armazenamento gerenciado de sessão mantendo o diretório de trabalho montado entre pausas — inclusive para tarefas agendadas que acumulam estado entre execuções diárias. A equipe de Platform Engineering da Thomson Reuters também construiu um hub agêntico no AgentCore que automatiza provisionamento de contas cloud, patching de banco de dados e revisão de arquitetura, reportando ganho de produtividade de 15x no lançamento.

    Uma frota de agentes trabalhando em paralelo

    O repositório GitHub de acompanhamento transforma o conceito em três experimentos executáveis. Cada um começa da mesma forma: a aplicação chama o AgentCore Runtime uma vez por agente, cada chamada cai em sua própria microVM, e a partir daí cada agente trabalha em sua própria cópia do projeto.

    • Race — quem corrige primeiro? Um issue do GitHub é enviado para quatro agentes ao mesmo tempo. Cada um roda em sua própria microVM e abre o PR via Gateway. Os competidores são Claude Code, Codex CLI, Kiro CLI e Cursor CLI.
    • Bench — quem corrige melhor? Mesma configuração, mas em vez de declarar um vencedor, o script avalia todos. Latência, custo em dólar e taxa de aprovação nos testes por execução são gravados em CSV. Ao repetir com diferentes combinações de modelo × harness, a pergunta “qual modelo é melhor para nossa base de código?” passa a ter resposta baseada em dados.
    • Watch — acompanhar o agente de perto. Um agente de refactor de longa duração, duas horas, rodando sem supervisão. Enquanto trabalha, o desenvolvedor abre um terminal localmente e executa agentcore exec --it contra a mesma sessão — entrando na mesma microVM que o agente, podendo acompanhar logs, ler stack traces ou deixar uma nota em um arquivo que o agente relê no próximo passo.
    AGENTS = {
        "claude-code": {
            "name": "Claude Code",
            "config_dir": os.path.join(AGENTS_DIR, "claude-code"),
            "run_cmd": "/app/run.sh {model_flag}'{prompt}'; exit",
            "default_model": "global.anthropic.claude-opus-4-8",  # Opus 4.8
        },
        "kiro": {
            "name": "Kiro",
            "config_dir": os.path.join(AGENTS_DIR, "kiro"),
            "run_cmd": "/app/run.sh {model_flag}chat '{prompt}'; exit",
            "default_model": "auto",  # Automatic model option from Kiro
        },
        "codex": {
            "name": "Codex",
            "config_dir": os.path.join(AGENTS_DIR, "codex"),
            "run_cmd": "/app/run.sh {model_flag}'{prompt}'; exit",
            "default_model": "openai.gpt-5.5",  # GPT 5.5
        },
        "hermes": {
            "name": "Hermes",
            "config_dir": os.path.join(AGENTS_DIR, "hermes"),
            "run_cmd": "/app/run.sh {model_flag}'{prompt}'; exit",
            "default_model": "global.meta.llama4-maverick-17b-instruct-v1:0",  # Llama model
        }
    }

    A invocação pode ser feita de forma não-interativa:

    client.invoke_agent_runtime_command(
        agentRuntimeArn=ARN,
        runtimeSessionId=sid,
        body={"command": "cd /mnt/workspace && npm test", "timeout": 300},
    )

    Ou de forma interativa no terminal:

    client.invoke_agent_runtime_command_shell(
        agentRuntimeArn=ARN,
        runtimeSessionId=sid
    )
    Imagem original — fonte: Aws

    O resultado é múltiplas abas, múltiplas janelas, cada uma conectada a uma microVM diferente. O notebook deixa de fazer o trabalho e passa a ser o ponto de supervisão de uma frota de agentes.

    Recursos adicionais

    Fonte

    It’s safe to close your laptop now: Hosting coding agents on Amazon Bedrock AgentCore (https://aws.amazon.com/blogs/machine-learning/its-safe-to-close-your-laptop-now-hosting-coding-agents-on-amazon-bedrock-agentcore/)

  • Operacionalizando a segurança AWS: um roteiro de maturidade em 6 fases

    Habilitar não é o mesmo que operar

    Ativar ferramentas de segurança é apenas o começo. O verdadeiro desafio — onde a maioria das organizações trava — é fazer com que essas ferramentas dirijam decisões reais: tempos de resposta mensuráveis, postura de segurança melhorando semana a semana, e alertas que chegam às pessoas certas na hora certa.

    A AWS publicou um roteiro de maturidade operacional voltado para organizações que já habilitaram o AWS Security Hub e o Amazon GuardDuty. Esses dois serviços formam a base de uma operação de segurança centrada na nuvem: o Security Hub centraliza o gerenciamento de postura e agrega alertas de múltiplos serviços, enquanto o GuardDuty monitora continuamente atividades maliciosas e comportamentos não autorizados.

    Se você ainda não habilitou esses serviços, a documentação do Security Hub e a documentação do GuardDuty cobrem a configuração inicial, incluindo implantação multi-conta com o AWS Organizations.

    O roteiro a seguir não explica como cada funcionalidade trabalha — a documentação já faz isso bem. O foco aqui é quando e por que usar cada capacidade, e como construir os hábitos organizacionais que tornam tudo isso efetivo.

    Fase 0: Avalie o estado atual

    Objetivo: entender o que está funcionando antes de mudar qualquer coisa.
    Prazo estimado: 1 a 2 semanas.

    Antes de introduzir novos processos ou automações, é essencial ter uma visão clara do ambiente. Essa avaliação orienta todas as decisões seguintes. Os pontos a verificar são:

    • Inventário de alertas: quantos alertas ativos do GuardDuty existem, qual a distribuição por severidade e qual é o mais antigo. Um backlog grande de alertas CRÍTICOS ou ALTOS sem revisão há semanas é um sinal claro de onde focar.
    • Baseline do Security Hub: qual é o score atual contra as Práticas de Segurança Fundamentais da AWS (FSBP) e o CIS AWS Foundations Benchmark. Verificar quais padrões estão habilitados e se há sobreposições criando ruído.
    • Cobertura multi-conta e multi-região: o GuardDuty está habilitado em todas as contas e regiões? Agentes de ameaça frequentemente operam em regiões que as organizações não monitoram ativamente. Verificar também se o Security Hub está configurado com uma conta de administrador delegado.
    • Integrações: os alertas do GuardDuty estão fluindo para o Security Hub? O Amazon Inspector e o Amazon Macie estão habilitados e alimentando alertas?
    • Notificações: existe uma regra de Amazon EventBridge configurada? Os alertas estão sendo roteados para algum canal — seja um tópico do Amazon Simple Notification Service (Amazon SNS) ou uma integração de chat? Sem esse fluxo, alertas se acumulam silenciosamente no console sem que ninguém olhe.

    Entregável: uma avaliação de uma página identificando o que está habilitado, o que está fluindo para onde, quem está revisando e qual é o backlog existente.

    Fase 1: Reduza o ruído

    Objetivo: tornar o sinal significativo antes de pedir que alguém aja sobre ele.
    Prazo estimado: 2 a 3 semanas.

    Esta é a fase mais importante de todo o roteiro. Pular essa etapa em favor de automação resulta em caos automatizado. A fadiga de alertas é o principal motivo pelo qual ferramentas de segurança são ignoradas.

    Ajuste fino do GuardDuty

    Crie regras de supressão para alertas sabidamente benignos — como tráfego esperado de IPs corporativos (usando listas de IPs confiáveis), ferramentas internas que disparam alertas de DNS, ou recursos expostos à internet que recebem varreduras de porta naturalmente. Se você investigou um alerta e ele é esperado, suprima-o.

    Triar todos os alertas ALTOS e CRÍTICOS ativos em três categorias: (1) precisa de investigação imediata, (2) verdadeiro positivo já endereçado (arquivar via status de fluxo de trabalho), ou (3) falso positivo ou comportamento esperado (criar regra de supressão).

    Revisar também os planos de proteção do GuardDuty. Organizações que habilitaram o serviço há anos podem não ter ativado planos lançados depois, como Runtime Monitoring, Malware Protection, RDS Protection e Lambda Protection.

    Ajuste fino do Security Hub

    Desabilitar controles irrelevantes para o ambiente é o ganho rápido de maior valor. Um score de 47% onde metade das falhas são irrelevantes treina as equipes a ignorar o painel completamente. Consulte a referência de controles do Security Hub para a lista completa.

    Escolher um padrão primário: o FSBP é uma boa escolha padrão. O CIS Benchmark agrega valor quando há mandato de conformidade específico. Evitar habilitar PCI DSS ou NIST 800-53 sem requisito de reporte — eles adicionam volume sem sinal proporcional.

    Configurar a agregação entre regiões para a conta de administrador delegado, eliminando a necessidade de verificar alertas em múltiplos consoles regionais.

    Usar o campo de status de fluxo de trabalho operacionalmente: alertas devem progredir de NOVO para NOTIFICADO para RESOLVIDO ou SUPRIMIDO. Se tudo permanece em NOVO indefinidamente, o sistema não tem significado operacional.

    Fase 2: Construa a camada de notificação e roteamento

    Objetivo: levar os alertas certos às pessoas certas no momento certo.
    Prazo estimado: 2 a 3 semanas.

    A arquitetura recomendada é: Security Hub → regra do EventBridge → lógica de roteamento → destino. A estratégia de notificação deve ser em camadas por severidade:

    • CRÍTICO: acionar on-call imediatamente (PagerDuty ou Opsgenie) — SLA de 15 minutos.
    • ALTO: alertar canal da equipe de segurança e criar ticket (Slack/Teams + Jira/ServiceNow) — SLA de 4 horas.
    • MÉDIO: criar ticket para revisão — SLA de 48 horas.
    • BAIXO/INFORMACIONAL: digest semanal ou revisão por dashboard.

    Decisões de design importantes: rotear a partir do Security Hub, não dos serviços individuais, pois todos os alertas agregam lá. Criar um caminho rápido para tipos de alertas mais perigosos — especialmente os do GuardDuty envolvendo exfiltração de credenciais, atividade de criptomoedas, trojans e comprometimentos ativos — consultando a referência de tipos de alertas do GuardDuty.

    Enriquecer notificações antes da entrega usando uma função do AWS Lambda para formatar alertas com alias da conta, região, Nome de Recurso da Amazon (ARN), tipo de alerta, severidade, link direto para o console e descrição em linguagem simples. O guia de integração do Security Hub com CloudWatch Events descreve o formato do evento.

    Fase 3: Construa remediação automatizada para alertas de alta confiança

    Objetivo: para alertas onde a resposta correta é determinística, remover o humano do loop.
    Prazo estimado: 3 a 4 semanas.

    O princípio orientador: auto-remediar apenas quando três condições são atendidas simultaneamente — o alerta é de alta confiança, a resposta é determinística, e o raio de impacto da ação automatizada é limitado.

    Categorias comuns de auto-remediação:

    • Isolamento de instância para comprometimentos confirmados (mineração de criptomoeda, malware, trojans): substituir o grupo de segurança, tirar snapshot dos volumes para forense e notificar.
    • Revogação de credenciais para comprometimento confirmado: anexar políticas de negação total, revogar sessões e desativar chaves de acesso.
    • Correção de desvio de conformidade para configurações incorretas determinísticas: reabilitar o bloqueio de acesso público do Amazon Simple Storage Service (Amazon S3), revogar regras de grupo de segurança excessivamente permissivas, reabilitar o AWS CloudTrail.
    • Escalação apenas por notificação para alertas que exigem julgamento humano: lacunas de criptografia no Amazon Elastic Block Store (Amazon EBS) e rotação de chaves de acesso.

    Para implementação, a AWS disponibiliza o Security Hub Automated Response and Remediation (SHARR), uma solução com playbooks de remediação pré-construídos implantados como workflows do AWS Step Functions acionados pelo EventBridge. Para alertas recorrentes por falta de controles preventivos, a melhor resposta de longo prazo costuma ser uma política de controle de serviço (SCP) que impede a configuração incorreta de ocorrer.

    Fase 4: Construa o ritmo operacional

    Objetivo: transformar o gerenciamento de alertas em uma prática organizacional sustentada, não uma limpeza pontual.
    Prazo estimado: 4 a 6 semanas para estabelecer, depois contínuo.

    Esta é a fase onde a maioria das organizações trava — e a mais importante de todo o roteiro. A tecnologia está funcionando, as notificações estão fluindo, as remediações automáticas estão disparando, mas não há hábito organizacional construído em torno disso. Sem esta fase, tudo que foi construído nas fases anteriores vai gradualmente se deteriorar.

    Revisão semanal de segurança (30 minutos)

    Participantes: líder da equipe de segurança, representante da equipe de plataforma de nuvem e um líder de engenharia rotativo de uma equipe de aplicação. A rotatividade do representante de engenharia é fundamental: ela constrói consciência de segurança em toda a organização, garante que alertas cheguem a quem tem contexto para resolvê-los, e cria responsabilidade além da equipe de segurança.

    Pauta sugerida:

    • 5 min — Tendência do score de conformidade: está melhorando, caindo ou estagnado?
    • 5 min — Revisão de alertas CRÍTICOS e ALTOS: algum precisa de escalação imediata?
    • 10 min — Top 5 controles com mais falhas: atribuir dono e data-alvo para cada.
    • 5 min — Revisão de automações: alguma disparou esta semana? Funcionou corretamente?
    • 5 min — Decisões de ajuste: novas regras de supressão necessárias? Novos candidatos à auto-remediação?

    Métricas mensais

    As métricas a acompanhar mensalmente incluem: Tempo Médio para Reconhecimento (MTTA) de alertas CRÍTICOS, Tempo Médio para Resolução (MTTR) de alertas CRÍTICOS e ALTOS, score de conformidade do Security Hub por padrão e por conta, número de alertas ativos do GuardDuty por severidade, proporção de alertas auto-remediados versus resolvidos manualmente, e taxa de adesão aos Acordos de Nível de Serviço (SLAs) por severidade.

    Para visualização, a AWS sugere usar dashboards do Amazon CloudWatch para visibilidade operacional em tempo real, ou o Amazon QuickSight conectado ao Security Hub via Amazon Security Lake para análise histórica e relatórios executivos.

    Revisões trimestrais

    A revisão trimestral é uma inspeção mais profunda do sistema em si — não apenas dos alertas, mas da maquinaria que os processa. O checklist inclui: auditoria de regras de supressão (a condição subjacente ainda existe?), auditoria de controles desabilitados (a justificativa ainda é válida?), revisão de funções do AWS Identity and Access Management (IAM) usadas por funções de remediação, e avaliação de novos planos de proteção e controles lançados no trimestre.

    Rubrica de maturidade operacional

    A AWS propõe pontuar seis dimensões de 1 a 3 para avaliar a maturidade do ritmo operacional: cadência de revisão, rastreamento de métricas, propriedade de alertas, gestão de automação, ciclo de vida de ajuste e engajamento entre equipes. A pontuação total classifica a organização em: Iniciando (6–9), Estabelecida (10–14) ou Otimizada (15–18).

    Entregável: uma cadência operacional documentada com propriedade clara (considere uma matriz RACI), dashboards de métricas, procedimentos de escalação e um ciclo de melhoria contínua. A cadência deve sobreviver à rotatividade da equipe — se depende de uma pessoa lembrar de executá-la, ainda não é operacional.

    Fase 5: Amadureça a arquitetura

    Objetivo: preencher lacunas remanescentes e construir em direção a uma capacidade abrangente de operações de segurança.
    Prazo estimado: contínuo, priorizado pelo perfil de risco organizacional.

    • Amazon Inspector: habilitar para instâncias EC2, funções Lambda e imagens de container no Amazon Elastic Container Registry (Amazon ECR). Os alertas fluem automaticamente para o Security Hub, adicionando gerenciamento de vulnerabilidades.
    • Amazon Macie: habilitar para buckets S3 com dados potencialmente sensíveis. Especialmente importante para organizações com requisitos de conformidade em torno de Informações de Identificação Pessoal (PII), informações de saúde protegidas (PHI) ou dados de Payment Card Industry (PCI). Configurar a descoberta automatizada de dados sensíveis.
    • Amazon Security Lake: centraliza logs relevantes de segurança no formato OCSF para retenção de longo prazo, investigação forense e caça a ameaças.
    • Camada de controles preventivos: converter alertas detectivos recorrentes em políticas preventivas usando SCPs para impedir desabilitar GuardDuty, Security Hub e CloudTrail; limites de permissão IAM em papéis de desenvolvedores; AWS WAF em endpoints públicos; e AWS Network Firewall para inspeção de tráfego de VPC.
    • Expansão de controles detectivos: AWS IAM Access Analyzer para alertas de acesso externo e acesso não utilizado; AWS CloudTrail Lake para logs de auditoria consultáveis de longo prazo; e regras customizadas do AWS Config para verificações de conformidade específicas da organização.
    • Prontidão para resposta a incidentes: playbooks referenciando tipos específicos de alertas do GuardDuty, infraestrutura forense pré-construída, exercícios de simulação regulares e templates do AWS CloudFormation para implantar infraestrutura de isolamento sob demanda. O Guia de Resposta a Incidentes de Segurança da AWS oferece um framework abrangente.

    Por onde começar agora

    O roteiro completo não precisa ser executado de uma vez. As fases 0 e 1 podem ser concluídas em 3 a 5 semanas e entregam clareza imediata. As fases 2 e 3 constroem a infraestrutura de resposta nas 5 a 7 semanas seguintes. A fase 4 é o que torna tudo sustentável — e merece a maior atenção.

    Se você pudesse fazer uma coisa agora: execute a avaliação da Fase 0 esta semana. Esse único entregável diz exatamente onde focar a seguir. Um ambiente ajustado com notificações funcionando e uma cadência semanal de revisão é dramaticamente mais efetivo do que um deployment repleto de recursos, mas negligenciado.

    Para aprofundar, a AWS disponibiliza o Guia do Usuário do AWS Security Hub, o Guia do Usuário do Amazon GuardDuty e o Guia de Resposta a Incidentes de Segurança da AWS.

    Fonte

    Operationalizing AWS security: A maturity roadmap (https://aws.amazon.com/blogs/security/operationalizing-aws-security-a-maturity-roadmap/)

  • Resumo de Segurança AWS: Maio de 2026

    O que aconteceu na segurança AWS em maio de 2026

    Todo mês a AWS publica um digest consolidando as principais novidades de segurança: posts técnicos, recursos novos, repositórios de código e boletins de vulnerabilidades. O de maio de 2026 chegou com um tema central bem claro: a segurança de IA deixou de ser algo pontual e passou a exigir proteção em toda a pilha — do modelo ao fluxo agêntico, passando por políticas de autorização e conformidade regulatória.

    A seguir, a CloudTroop comenta cada bloco de conteúdo publicado pela AWS neste mês.

    Posts do Blog de Segurança AWS

    Segurança de IA

    Quatro posts abordaram o tema de segurança em ambientes de inteligência artificial, cobrindo desde fundamentos até frameworks estruturados.

    Segurança de Infraestrutura

    Quatro posts cobriram proteção de rede, análise de tráfego e migração de arquitetura de firewall.

    Gerenciamento de Identidade

    Dois posts abordaram roteamento regional e automação do ciclo de vida de identidades.

    Governança e Conformidade

    Cinco posts cobriram novos guias de conformidade, governança de infraestrutura como código e importação de dados históricos de auditoria.

    Proteção de Dados

    Detecção e Resposta a Ameaças

    Três posts cobriram mineração de criptomoedas, segurança da cadeia de suprimentos de software e o AWS Security Hub Extended.

    Segurança de Aplicações

    Treinamento e Capacitação

    Boletins de Segurança de Maio

    A AWS publicou investigações sobre vulnerabilidades de segurança reportadas em serviços, softwares e produtos Amazon e AWS. Abaixo estão os boletins do mês:

    AWS Samples: novos repositórios do mês

    Maio trouxe 8 novos repositórios no AWS Samples, cobrindo segurança de aplicações, proteção de dados, segurança de infraestrutura, governança e segurança de IA.

    Segurança de Aplicações

    Proteção de Dados

    • Auditoria de acesso ao KMS — Resolve e reporta quem pode usar suas chaves do AWS Key Management Service (KMS) em políticas do IAM, políticas de chave e concessões, com resolução do IAM Identity Center para identificar as pessoas por trás de roles de SSO.

    Segurança de Infraestrutura

    Governança

    Segurança de IA

    AWS Labs: novo repositório de governança

    Maio trouxe também 1 novo repositório no AWS Labs, focado em governança para instituições de pesquisa.

    O que maio de 2026 sinaliza

    O digest de maio mostra que a segurança de IA está amadurecendo: saiu do nível de controles de modelo e avançou para proteção de pilha completa em fluxos agênticos. Os posts e amostras trazem padrões para autorização baseada em políticas com Cedar, filtragem de tráfego de rede por categoria e monitoramento de conformidade entre contas. Os boletins de segurança endereçam vulnerabilidades em SDKs, drivers e ferramentas para desenvolvedores. Cada recurso inclui passos de implantação ou código executável para que as equipes possam validar em seus próprios ambientes antes de adotar.

    Para acompanhar as atualizações conforme são publicadas, a AWS disponibiliza o feed RSS do Blog de Segurança AWS.

    Fonte

    ICYMI: May 2026 @AWS Security (https://aws.amazon.com/blogs/security/icymi-may-2026-aws-security/)

  • Decisões melhores em escala: como a otimização matemática vai além da intuição

    Quando a intuição não é suficiente

    Toda grande empresa enfrenta decisões que ultrapassam a capacidade humana de análise manual. Qual sequência de rotas de entrega minimiza custos e ainda garante a promessa de entrega no dia seguinte? Como centenas de robôs devem se mover por um chão de fábrica sem colidir? Como escalar a equipe de enfermagem de uma rede de coleta de sangue de forma justa, eficiente e dentro das normas trabalhistas?

    Esses problemas têm algo em comum: o número de combinações possíveis é tão vasto que nenhum ser humano — e nenhuma regra simples — consegue encontrar a melhor resposta de forma confiável. E o custo de uma escolha errada é alto.

    É exatamente para esse tipo de desafio que a AWS vem destacando a otimização matemática como uma abordagem complementar ao aprendizado de máquina (ML). Em publicação recente, a empresa detalha como o AWS Generative AI Innovation Center aplica essa ciência para resolver os problemas mais complexos de seus clientes.

    O que é otimização matemática e onde ela se encaixa na IA

    A otimização matemática é a ciência de encontrar a melhor decisão possível dentro de um conjunto enorme de alternativas, respeitando restrições do mundo real. Diferente de outras abordagens de IA, ela não descreve o que aconteceu nem prevê o que pode acontecer — ela prescreve o que deve ser feito para atingir um objetivo, dadas as restrições existentes.

    Para entender melhor o contraste com o ML tradicional, vale observar a diferença fundamental entre as duas abordagens:

    • Aprendizado de máquina (ML) é uma IA indutiva: aprende padrões a partir de muitos exemplos e gera previsões probabilísticas. É excelente para reconhecimento de padrões em dados não estruturados.
    • Otimização matemática é uma IA dedutiva: aplica princípios matemáticos a problemas específicos e entrega decisões definitivas e comprovadamente ótimas. É ideal para raciocínio exato sobre restrições rígidas e horizontes de planejamento longos.

    A maioria das soluções de IA empresarial é probabilística — ela aprende padrões e fornece uma resposta provável. Para tarefas de reconhecimento de padrões, isso funciona bem. Mas decisões operacionais com restrições rígidas — conformidade regulatória, limites físicos de capacidade, janelas de tempo — exigem respostas definitivas, não aproximações confiantes. A otimização encontra a solução matematicamente melhor dentro dessas restrições. “Esta rota é provavelmente eficiente” se transforma em “esta é a rota ótima considerando todas as restrições do seu sistema.”

    ML e otimização: não são concorrentes, são parceiros

    Um ponto importante destacado pela AWS é que otimização matemática e ML não competem entre si — eles se complementam em pipelines do tipo predict-then-optimize (prever e depois otimizar): modelos de ML fazem previsões de demanda ou falhas, e a otimização usa essas previsões para tomar as melhores decisões possíveis.

    Um exemplo concreto é a rede logística da Amazon na Europa: 90 armazéns, 34 centros de triagem, 242 estações de distribuição e mais de 11.000 rotas. Modelos de ML preveem padrões de demanda nessa rede. Mas decidir quando os caminhões devem partir — respeitando restrições de turno, capacidade e espaçamento — exige otimização. O Innovation Center desenvolveu duas abordagens complementares de otimização que entregaram melhorias de +20 a +50 pontos-base na cobertura de entregas no dia seguinte, representando dezenas de milhões de dólares em valor de negócio.

    Outro caso que ilustra bem essa integração é o da Fidelity Center for Applied Technology (FCAT®). Os modelos de ML da equipe já entregavam forte desempenho preditivo para decisões de investimento e gestão de risco, mas havia uma demanda por maior interpretabilidade. Em colaboração com o Innovation Center, foram construídas técnicas de otimização que incorporam explicabilidade diretamente na construção dos modelos — em vez de tentar explicar uma caixa-preta após o fato. O resultado foi uma IA em conformidade regulatória sem sacrifício no desempenho preditivo, além de frameworks reutilizáveis para desenvolvimento contínuo.

    Como o Innovation Center estrutura o trabalho

    O AWS Generative AI Innovation Center conta com uma equipe de cientistas especializados que combinam expertise em IA, modelagem matemática, otimização, computação quântica e computação de alto desempenho. A abordagem segue um framework de quatro etapas:

    • Descobrir: identificar oportunidades de otimização de alto impacto, mapear abordagens existentes e definir objetivos claros com critérios de sucesso mensuráveis.
    • Modelar: construir uma representação matemática do problema de negócio, capturando objetivos (o que otimizar), variáveis de decisão (o que pode ser controlado) e restrições (o que limita as escolhas). Um modelo bem construído transforma um desafio de negócio vago em uma formulação precisa e solucionável.
    • Resolver: projetar ou configurar a abordagem algorítmica certa para o tamanho e a estrutura do problema — desde métodos exatos como programação por restrições e programação inteira mista, até meta-heurísticas como algoritmos genéticos, passando por heurísticas customizadas.
    • Arquitetar: usar os serviços da AWS para projetar uma infraestrutura em nuvem que escale, se integre aos sistemas existentes e entregue resultados dentro das janelas operacionais de tempo.

    Casos reais: resultados concretos

    BMW Group: sequenciamento de robôs na linha de produção

    O BMW Group utiliza centenas de robôs por planta para aplicar selante nas costuras da carroceria dos carros — um processo essencial para impermeabilização e proteção contra corrosão. Determinar a sequência ótima de movimentos de cada robô — qual costura atender primeiro, em qual direção, com qual ferramenta — gera mais combinações possíveis do que qualquer humano ou regra simples consegue avaliar.

    O Innovation Center aplicou o framework de quatro etapas: identificou o gargalo de sequenciamento, modelou o problema como uma otimização combinatória sobre caminhos de robôs e trocas de ferramentas, resolveu com algoritmos customizados ajustados à estrutura do problema, e arquitetou uma solução reutilizável que a BMW pode agora aplicar a qualquer desafio de sequenciamento em suas operações de manufatura. O resultado: até 10% de melhoria no tempo de ciclo dos robôs por carroceria.

    Delivery Hero: logística de médio alcance

    A Delivery Hero, líder em entrega de alimentos e comércio rápido, move de 50 a 150 paletes de mantimentos diariamente de centros de distribuição para centros de atendimento de bairro em ambientes urbanos densos, com destinos variáveis e janelas de tempo rígidas. Esse planejamento era feito manualmente.

    O Innovation Center construiu uma solução automatizada de roteamento de veículos na AWS que demonstrou potencial de até 24% de economia nos custos de planejamento de logística de médio alcance em múltiplos setores, além de melhorar a confiabilidade do reabastecimento e reduzir atrasos nas entregas.

    Australian Red Cross Lifeblood: escalonamento de força de trabalho

    A Australian Red Cross Lifeblood é uma organização sem fins lucrativos australiana que coletou mais de 1,6 milhão de doações de sangue em 2023 — um crescimento de 600.000 em relação a 2022. Toda essa operação depende de milhares de enfermeiros distribuídos em cerca de 100 centros de doação. Garantir que cada centro esteja adequadamente staffado, com o número certo de profissionais e o nível de expertise necessário, considerando fatores do mundo real, é um problema de otimização combinatória extremamente complexo.

    O Innovation Center formulou o problema em escala industrial como um modelo de programação por restrições e utilizou o solver CP-SAT de última geração. Com dados sintéticos, demonstrou uma redução teórica de 7% nos custos — e uma redução de 46% ao dobrar a oferta de profissionais.

    De soluções pontuais a metodologias reutilizáveis

    Um aspecto relevante destacado pela AWS é que as melhores soluções geram metodologia reutilizável, não apenas resultados únicos. Os dois casos acima originaram soluções aceleradas disponíveis para novos clientes:

    • ROaDS — Route Optimization and Dispatch Solution (Solução de Otimização de Rotas e Despacho): nascida do trabalho com a Delivery Hero, é um framework configurável para roteamento de veículos, otimização logística e planejamento de serviços de campo. Codifica padrões de solução comprovados em componentes que aceleram o tempo de entrega de valor.
    • WISE — Workforce Intelligence and Scheduling Engine (Motor de Inteligência e Escalonamento de Força de Trabalho): construída sobre a metodologia da Lifeblood, é uma base configurável para escalonamento e rostering de força de trabalho em diversos setores. Oferece um ponto de partida robusto que pode ser adaptado às restrições únicas de cada organização.

    Ambas as soluções garantem propriedade total ao cliente e flexibilidade para customização — reduzindo o caminho até a produção enquanto endereçam os objetivos específicos de cada organização.

    O que isso significa para empresas que buscam escalar decisões complexas

    A mensagem central da AWS é clara: a otimização matemática transforma decisões operacionais complexas em vantagens competitivas. Os números falam por si — 10% de ganho em eficiência de produção, 24% de redução em custos logísticos, dezenas de milhões em receita incremental por melhor cobertura de entregas.

    Do roteamento ao escalonamento, passando por design de redes, o Innovation Center combina profundidade científica e expertise em AWS para entregar resultados mensuráveis. Para empresas que estão explorando seu primeiro caso de uso de otimização ou escalando uma capacidade de nível empresarial, a AWS recomenda iniciar uma conversa com a equipe de conta AWS sobre fluxos de trabalho, dados disponíveis e resultados de negócio esperados.

    Fonte

    Better decisions at scale: How mathematical optimization delivers where intuition fails (https://aws.amazon.com/blogs/machine-learning/better-decisions-at-scale-how-mathematical-optimization-delivers-where-intuition-fails/)

  • Inferência de Machine Learning com Criptografia Ponta a Ponta no Amazon SageMaker AI e FHE

    O problema: como processar dados sensíveis na nuvem sem expô-los?

    Inferência de aprendizado de máquina (ML) frequentemente envolve informações altamente sensíveis — prontuários médicos, dados corporativos proprietários ou comunicações pessoais. A grande questão é: como aproveitar a escalabilidade da nuvem sem entregar esses dados a terceiros?

    A AWS publicou uma abordagem técnica que responde exatamente a isso: usar o Amazon SageMaker AI combinado com Criptografia Totalmente Homomórfica (FHE — Fully Homomorphic Encryption) para executar inferência de ML com os dados permanecendo criptografados durante todo o processo — inclusive enquanto o modelo está processando a consulta. Nem o próprio SageMaker AI tem acesso ao conteúdo em texto simples.

    O que é Criptografia Totalmente Homomórfica (FHE)?

    FHE é uma forma de criptografia que permite realizar operações matemáticas diretamente sobre dados criptografados, sem precisar descriptografá-los. No contexto de ML, isso significa que um modelo pode receber uma consulta cifrada, processá-la e devolver uma predição também cifrada — sem jamais ver o conteúdo original. Apenas o cliente, que possui a chave privada, consegue descriptografar o resultado.

    Essa abordagem é diferente — e complementar — a ambientes de computação confidencial como o Nitro System da AWS no Amazon EC2. Com o AWS Nitro Enclaves, os dados são descriptografados e processados em ambientes isolados de hardware. Com FHE, os dados nunca são descriptografados: a segurança é garantida pela matemática, não pelo hardware.

    Casos de uso práticos

    A AWS ilustra três cenários onde essa capacidade é especialmente valiosa:

    • Saúde: uma operadora de plano de saúde quer oferecer a médicos um modelo que prediz resultados de procedimentos com base em dados diagnósticos. Publicar o modelo na nuvem simplifica a operação, mas regulações de privacidade impedem expor dados de pacientes a terceiros.
    • Setor de energia: uma empresa de petróleo e gás usa ML para avaliar fotos de satélite de possíveis locais de perfuração. Hospedar o modelo na nuvem reduz custos, mas as imagens envolvem locais politicamente sensíveis.
    • Telecomunicações: uma operadora quer processar e-mails de clientes para detectar spam e phishing. A escala exige ML na nuvem, mas regulações de proteção de dados exigem que as mensagens permaneçam criptografadas em terceiros.

    A biblioteca concrete-ml: uma abordagem de alto nível

    Um post anterior no blog da AWS já havia abordado FHE para inferência no SageMaker, mostrando como implementar um algoritmo de regressão linear do zero usando a biblioteca de baixo nível SEAL. Desta vez, a abordagem é mais flexível: usa a concrete-ml, uma biblioteca de alto nível desenvolvida especificamente para inferência com FHE, compatível com a API do scikit-learn e que suporta vários tipos de modelos prontos para uso.

    Vale destacar: a concrete-ml é disponibilizada pela Zama para prototipagem ou uso não comercial sem licença paga. Para uso comercial, pode ser necessária uma licença comercial.

    Visão geral da solução

    O fluxo completo da solução funciona da seguinte forma:

    • O dono do modelo prepara e normaliza os dados de treinamento (por exemplo, para a escala [-1, 1]).
    • O modelo é treinado em uma versão habilitada para FHE — projetada para operar sobre dados criptografados.
    • O modelo é hospedado no SageMaker AI.
    • Clientes criptografam suas consultas usando o esquema FHE compatível com o modelo.
    • As consultas criptografadas são enviadas ao endpoint, que as processa sem descriptografar nenhum valor.
    • O endpoint retorna a predição criptografada ao cliente, que a descriptografa localmente.

    Pré-requisitos

    Para implementar essa solução, são necessários:

    Políticas de IAM para essas roles, junto com um exemplo funcional usando o corpus MNIST de dígitos manuscritos, estão disponíveis no repositório de código de exemplo.

    Treinamento

    Container de treinamento

    O container de treinamento é construído a partir de uma imagem python:3.12, com as dependências sagemaker_training, concrete-ml, concrete-python e torch instaladas. A atenção à paridade de versões entre Python, concrete-ml e concrete-python é obrigatória — a biblioteca exige consistência em todo o sistema.

    O Dockerfile.training tem o seguinte conteúdo:

    FROM python:3.12
    RUN apt-get update && apt-get upgrade -y && apt-get clean
    RUN apt-get -y install --no-install-recommends cmake
    RUN pip install sagemaker_training==5.1.1 concrete-ml==1.9.0 concrete-python==2.10.0 torch==2.3.1

    Após construir a imagem localmente, ela deve ser enviada ao Amazon ECR com os comandos de autenticação, tag e push padrão.

    Script de treinamento

    O treinamento com concrete-ml não difere de qualquer outro framework de ML — e o container de treinamento funciona como qualquer outro container de treinamento customizado. O treinamento ocorre sobre dados em texto simples; a concrete-ml não exige pré-processamento além da normalização. O training_script.py segue este template:

    import argparse
    import os
    import numpy
    from concrete.ml.sklearn import <Model class to train>
    from concrete.ml.deployment import FHEModelDev
    
    def do_training(model_dir, train):
        # Load your data from the train directory
        # Train your model instance, then save it
        # with the following line.
        FHEModelDev(model_dir, model).save()
    
    def model_fn(model_dir):
        # SageMaker AI requires this function exist but doesn't use it
        raise NotImplementedError
    
    if __name__ == '__main__':
        parser = argparse.ArgumentParser()
        parser.add_argument('--model-dir', type=str, default=os.environ['SM_MODEL_DIR'])
        parser.add_argument('--train', type=str, default=os.environ['SM_CHANNEL_TRAINING'])
        args = parser.parse_args()
        do_training(args.model_dir, args.train)

    Framework customizado e execução do job

    Para integrar o container ao SageMaker AI, a AWS recomenda criar um framework customizado. O framework.py encapsula as configurações do container e simplifica o lançamento do job de treinamento.

    O job é iniciado com o start_training.py, que usa a instância ml.m5.xlarge para modelos pequenos ou ml.m5.4xlarge para modelos maiores. Após a conclusão, dois arquivos são salvos no bucket S3: server.zip (usado pelo endpoint de inferência) e client.zip (usado pelos clientes para criptografar consultas).

    Inferência

    Desafios técnicos específicos do FHE

    A inferência baseada em FHE traz algumas restrições técnicas novas em relação à inferência padrão:

    • Clientes precisam do client.zip para gerar chaves criptográficas.
    • Textos cifrados FHE podem ultrapassar os limites de tamanho de requisição do SageMaker AI — portanto, cliente e serviço precisam trocá-los via Amazon S3.
    • A avaliação FHE pode demorar mais do que os timeouts padrão do SageMaker AI, exigindo o uso de inferência assíncrona.
    • O endpoint precisa de uma chave de avaliação (um tipo de chave pública) fornecida pelo cliente para executar a avaliação FHE.

    Predictor do endpoint

    O predictor.py é um servidor Flask que recebe um JSON com dois URIs do S3 — um para a consulta criptografada e outro para a chave de avaliação. Ele baixa esses arquivos, executa o modelo FHE sobre eles e retorna a predição criptografada. O container de inferência inclui ainda os arquivos de boilerplate (nginx.conf, serve e wsgi.py) necessários para containers de inferência customizados no SageMaker. É importante aumentar o valor de timeout no nginx.conf para permitir que a avaliação FHE seja concluída.

    O Dockerfile.inference instala nginx, Flask, gunicorn, sagemaker, concrete-ml e concrete-python sobre a imagem base python:3.12.

    Deploy do endpoint

    O endpoint é implantado com configuração de inferência assíncrona. O start_inference_endpoint.py configura o modelo com a URI da imagem ECR, o caminho do modelo no S3 e a role IAM do endpoint. A instância mínima recomendada é ml.m5.xlarge; para melhor desempenho, ml.m5.24xlarge. Atenção: endpoints geram cobranças contínuas até serem excluídos. Consulte a tabela de preços do Amazon SageMaker AI e lembre-se de deletar o endpoint ao final dos testes.

    Cliente de inferência

    O client.py abstrai todos os detalhes de FHE do usuário final. Seu fluxo é:

    • Baixar o client.zip do S3.
    • Gerar as chaves privada e de avaliação.
    • Criptografar a consulta e fazer upload da consulta cifrada e da chave de avaliação para o S3.
    • Enviar os URIs ao endpoint e aguardar a resposta assíncrona.
    • Baixar a predição criptografada e descriptografá-la localmente.

    Uma observação de design: cliente e endpoint tratam consultas e respostas de forma diferente. A resposta criptografada é uma sequência de bytes que o SageMaker AI gerencia naturalmente. Já a consulta do cliente é uma estrutura JSON que precisa conter o URI da chave de avaliação — embutir a consulta criptografada nesse JSON exigiria codificação (como Base64), adicionando processamento desnecessário. Por isso, o código de exemplo gerencia o upload da consulta criptografada diretamente no S3.

    Desempenho e considerações de segurança

    FHE oferece proteção criptográfica robusta, mas com um custo de desempenho significativo. A sobrecarga pode chegar a 100.000x em relação à inferência em texto simples. Algumas formas de reduzir esse impacto:

    • Aumentar o número de vCPUs da instância.
    • Quantização: técnica de ML que reduz a precisão numérica usada na inferência. Como o tempo de execução do concrete-ml cresce com a precisão, a quantização tem impacto ainda maior aqui do que em ML convencional. A quantização pode reduzir a acurácia do modelo, mas não é afetada pela conversão para FHE. Nos testes descritos, a quantização no código do modelo reduziu a sobrecarga para 2800x (de 67ms para 187s em uma instância ml.m5.xlarge) sem perda observável de acurácia. Aumentando os vCPUs, é possível chegar a 500x (46s em uma ml.m5.24xlarge).

    Por isso, FHE ainda não é adequado para aplicações interativas sensíveis à latência. No entanto, é prático para cargas de trabalho assíncronas ou em lote, onde os requisitos de privacidade superam as preocupações com latência — exatamente o perfil dos três casos de uso apresentados.

    Limitações de segurança importantes

    • É fundamental que os clientes mantenham em segredo as consultas descriptografadas e as predições, pois a combinação de um texto cifrado com seu texto simples pode revelar informações sobre a chave secreta.
    • Esta solução não protege o sigilo do modelo. As consultas e respostas ficam opacas ao SageMaker AI, mas o modelo em si pode ser visível ao serviço. O modelo também pode ser vulnerável a ataques de “roubo de modelo” por quem tiver acesso a consultas e respostas em texto simples.
    • O concrete-ml não fornece privacidade de circuito: informações sobre o modelo podem ser reveladas pelos textos cifrados.

    A segurança é uma responsabilidade compartilhada entre a AWS e cada cliente. As boas práticas incluem: aplicar o princípio do menor privilégio nas roles IAM; habilitar criptografia padrão nos buckets S3 para valores que não sejam textos cifrados FHE; e restringir permissões dos buckets ao mínimo necessário.

    Limpeza de recursos

    Para evitar cobranças desnecessárias após os testes, é necessário excluir: o endpoint de inferência, a configuração do endpoint, o modelo no SageMaker AI, os artefatos no S3 (modelo, consultas cifradas, respostas cifradas e chaves de avaliação) e as imagens de container no ECR.

    Problemas comuns

    • TimeoutError durante inferência: aumente o max_attempts no WaiterConfig ou use um tipo de instância maior.
    • Erros de AccessDenied: verifique se as roles IAM têm as permissões corretas para S3 e SageMaker AI.
    • Falhas na construção do container: verifique se o Docker tem memória suficiente (acima de 8 GB).
    • Erros de servidor durante inferência: verifique a paridade de versões dos pacotes concrete-ml.

    Conclusão

    A combinação de SageMaker AI com FHE via concrete-ml permite realizar inferência sobre dados que permanecem criptografados do início ao fim do processo. Essa abordagem une a agilidade, escala e infraestrutura gerenciada do SageMaker AI com proteção criptográfica que vai da consulta até a resposta. Para cenários onde a privacidade dos dados é inegociável — saúde, energia, telecomunicações — essa arquitetura oferece um caminho concreto e implementável.

    Para aprofundamento, a AWS disponibiliza recursos adicionais:

    Fonte

    End-to-end encrypted ML inference with Amazon SageMaker AI and FHE (https://aws.amazon.com/blogs/machine-learning/end-to-end-encrypted-ml-inference-with-amazon-sagemaker-ai-and-fhe/)

  • CloudTroop Weekly #015 — 2026-w23





    CloudTroop Weekly #015 — 2026-w23

    7 de junho de 2026

    Resumo da Semana

    A semana consolidou um sinal claro: IA agêntica está saindo do laboratório e entrando em produção — com todas as responsabilidades que isso traz. AWS entregou peças importantes nessa direção: isolamento de tenants no Bedrock AgentCore, observabilidade de LLMs do nível de GPU até qualidade de resposta, e operações autônomas com open source. Paralelamente, segurança ganhou atenção com flow logs em tempo real no Shield Advanced e a nova API do KMS para auditar chaves ociosas. Para times brasileiros, destaque para o Cognito com replicação agora disponível em São Paulo.

    O que muda na prática

    • Operar LLMs em produção agora exige dashboard unificado correlacionando métricas de infraestrutura e qualidade de resposta — monitorar só CPU e memória não é mais suficiente.
    • A nova API GetKeyLastUsage do KMS fecha um gap histórico de auditoria: times de FinOps e compliance podem identificar chaves ociosas e reduzir custos sem risco de exclusão acidental.
    • Cognito com replicação multi-região disponível em sa-east-1 muda o padrão mínimo de resiliência para sistemas de autenticação com SLA elevado no Brasil.

    Ações da semana

    • Execute a API GetKeyLastUsage no seu ambiente de produção esta semana e liste chaves KMS sem uso nos últimos 90 dias — candidatas a desativação ou revisão de custo.
    • Se você opera LLMs no SageMaker, revise se seu stack de observabilidade atual captura métricas de qualidade de resposta além das métricas de infraestrutura — e avalie o guia de dashboard unificado publicado esta semana.

    Top 10 da Semana

    1

    Segurança multi-tenant em agentes de IA com Bedrock AgentCore

    Provedores SaaS que constroem plataformas de IA precisam de padrões concretos para isolar tenants sem duplicar infraestrutura — este guia entrega exatamente isso.

    Para quem: Arquitetos e engenheiros de segurança que desenvolvem plataformas multi-tenant com IA generativa.

    Segurança IA

    2

    Visibilidade total em ataques DDoS com flow logs no Shield Advanced

    Flow logs em tempo real durante ataques DDoS permitem análise forense e ajuste de mitigações sem infraestrutura adicional — mudança operacional significativa para equipes de segurança.

    Para quem: Engenheiros de segurança e SREs responsáveis por proteção de aplicações expostas à internet.

    DDoS Segurança

    3

    Nova API AWS KMS identifica chaves não utilizadas e evita exclusões

    A API GetKeyLastUsage resolve um gap histórico de auditoria no KMS, permitindo otimizar custos e prevenir exclusões acidentais de chaves críticas em produção.

    Para quem: Engenheiros de segurança, auditores de compliance e times de FinOps que gerenciam chaves criptográficas.

    KMS Compliance

    4

    Amazon Cognito ganha replicação multi-região com suporte em São Paulo

    Replicação de identidade em tempo quase real com failover transparente é um requisito crítico de resiliência para aplicações com SLA elevado — e agora está disponível em sa-east-1.

    Para quem: Arquitetos de soluções e engenheiros que precisam de alta disponibilidade em sistemas de autenticação.

    Resiliência Identidade

    5

    Bedrock Ops Alert: operações de IA autônomas e open source

    Solução open source que automatiza detecção de incidentes, ajuste de alarmes e abertura de chamados para workloads de IA generativa — reduz carga operacional de SREs diretamente.

    Para quem: SREs e engenheiros de plataforma que operam workloads de IA generativa em produção.

    AIOps Observabilidade

    6

    SFT + DPO no SageMaker aumenta precisão de agentes em 30%

    Combinar ajuste fino supervisionado com otimização de preferências permite alcançar desempenho superior com modelos menores, reduzindo custo de hospedagem de agentes de IA.

    Para quem: Cientistas de dados e engenheiros de ML que desenvolvem e otimizam agentes de IA em produção.

    Fine-tuning IA

    7

    Step Functions integra raciocínio agêntico com AgentCore

    Incorporar etapas de IA agêntica em workflows visuais com suporte a aprovação humana e rastreamento via CloudWatch acelera a adoção de automações inteligentes em processos existentes.

    Para quem: Arquitetos e desenvolvedores que constroem automações de processos com Step Functions.

    Workflows Agênticos

    8

    Controle de acesso granular B2C com Cognito e Verified Permissions

    A separação clara entre autenticação (Cognito) e autorização (Cedar/Verified Permissions) reduz débito técnico e melhora auditabilidade em aplicações B2C com regras de acesso complexas.

    Para quem: Desenvolvedores e arquitetos que constroem aplicações B2C com requisitos avançados de autorização.

    IAM Autorização

    9

    Observabilidade completa para LLMs no SageMaker: GPU à qualidade

    Dashboard unificado que correlaciona métricas de infraestrutura com qualidade de respostas de LLMs é essencial para operar modelos em produção com responsabilidade.

    Para quem: Engenheiros de ML e SREs responsáveis por LLMs em produção no SageMaker.

    Observabilidade LLM

    10

    ElastiCache para Valkey ganha durabilidade para dados críticos

    Durabilidade com latência de microssegundos abre o ElastiCache para casos de uso antes inviáveis, como memória persistente de agentes de IA e tokenização de pagamentos.

    Para quem: Arquitetos e engenheiros que usam cache em workloads que exigem baixa latência e persistência de dados.

    Cache Persistência


  • Permissões simplificadas para Amazon S3 Tables e views materializadas Iceberg chegam às regiões AWS GovCloud (US)

    O que foi anunciado

    A AWS anunciou que as permissões simplificadas para o Amazon S3 Tables e para as views materializadas do Apache Iceberg agora estão disponíveis nas regiões AWS GovCloud (US). A novidade envolve o suporte do AWS Glue Data Catalog à autorização baseada em IAM (Gerenciamento de Identidade e Acesso), trazendo uma forma mais direta de controlar quem acessa o quê em pipelines analíticos que utilizam esses recursos.

    O que muda na prática

    Antes dessa atualização, configurar permissões para trabalhar com S3 Tables ou views materializadas Iceberg exigia lidar com controles de acesso em camadas diferentes — armazenamento, catálogo e mecanismo de consulta — de forma separada. Com a autorização baseada em IAM agora suportada pelo Glue Data Catalog, é possível definir todas as permissões necessárias em uma única política IAM, cobrindo as três camadas de uma só vez.

    Essa consolidação simplifica a integração do S3 Tables e das views materializadas com os principais serviços de analytics da AWS, incluindo:

    • Amazon Athena
    • Amazon EMR
    • Amazon Redshift
    • AWS Glue

    Controle granular com AWS Lake Formation

    Para equipes que precisam de controles de acesso mais refinados, a AWS manteve a opção de adotar o AWS Lake Formation a qualquer momento. A adesão pode ser feita pelo Console de Gerenciamento da AWS, pela CLI, por API ou via AWS CloudFormation, permitindo definir permissões em nível mais granular sobre os dados.

    Disponibilidade nas regiões GovCloud

    Esse recurso está agora disponível nas regiões AWS GovCloud (US-East) e AWS GovCloud (US-West), ampliando o acesso a organizações governamentais e reguladas que operam nessas regiões com requisitos específicos de conformidade e soberania de dados.

    Saiba mais

    Para aprofundar o entendimento sobre como configurar e utilizar esses recursos, a AWS disponibiliza a documentação do S3 Tables e a documentação do AWS Glue Data Catalog.

    Fonte

    Simplified permissions for Amazon S3 Tables and Iceberg materialized views are now available in AWS GovCloud (US) Regions (https://aws.amazon.com/about-aws/whats-new/2026/06/gdc-s3tables-simplified-permissions-in-aws-govcloud/)