Category: Uncategorized

  • A AWS convidou um concorrente direto para o Security Hub Extended — e explica o porquê

    Quando o cliente aponta para o concorrente

    Existe um momento delicador para qualquer empresa de tecnologia: quando os próprios clientes recomendam uma solução que compete diretamente com algo que você já oferece. A AWS passou por isso com a Upwind — e, em vez de ignorar o sinal, decidiu trazer a empresa para dentro do AWS Security Hub Extended.

    A lógica é direta: o Security Hub Extended foi criado porque os clientes disseram o que funcionava para eles em segurança corporativa e pediram que a AWS simplificasse a adoção e a integração dessas ferramentas. A Upwind era um dos nomes que aparecia repetidamente nessas conversas. Então a AWS a trouxe para o programa.

    O que é o Security Hub Extended

    O Security Hub Extended é uma camada do AWS Security Hub que reúne soluções de segurança de terceiros dentro da mesma experiência comercial e operacional que os clientes já usam na AWS. A proposta é eliminar a fricção de compra, integração e operação: uma única fatura, suporte unificado e sem necessidade de construir integrações customizadas.

    Dentro do programa, os parceiros precisam ir além de um simples acordo — precisam comprometer engenharia, equipe comercial e modelo de precificação. A Upwind fez exatamente isso: trouxe todo o seu portfólio de soluções ao Extended com precificação pay-as-you-go desde o primeiro dia e alinhou sua equipe de vendas para atuar em negócios conjuntos com a AWS.

    Quem é a Upwind e o que a diferencia

    A Upwind é uma empresa de segurança de nuvem usada por companhias como Siemens, Peloton, Roku, Wix, Nextdoor e Nubank. A Fast Company a elegeu uma das empresas mais inovadoras de 2026.

    O diferencial técnico da Upwind está no conceito de proteção baseada em runtime. A maioria das soluções de segurança em nuvem analisa configurações periodicamente e reporta o que poderia ser um risco — uma abordagem estática de postura. A Upwind funciona de forma diferente: ela implanta um sensor baseado em eBPF diretamente no kernel Linux, que observa em tempo real o que as cargas de trabalho estão fazendo — comportamento de processos, conexões de rede, chamadas de API e interações entre contêineres.

    Isso significa que a Upwind não apenas aponta o que poderia ser explorado teoricamente, mas identifica o que está ativamente em risco agora. Essa distinção reduz drasticamente o volume de alertas e permite que as equipes de segurança foquem no que realmente importa.

    Escolha do cliente, não da AWS

    A AWS deixa claro que o princípio central do programa é a escolha do cliente:

    • Quem prefere gerenciamento de postura de segurança em nuvem e varredura de vulnerabilidades pode optar pelo Security Hub Essentials.
    • Quem prioriza proteção baseada em runtime pode escolher a Upwind.
    • Quem quiser os dois ao mesmo tempo pode combinar as soluções e obter resultados ainda mais robustos.

    A decisão é do cliente — não da AWS. Esse princípio vale para todos os parceiros do Security Hub Extended.

    Melhor juntos: o ecossistema integrado

    Uma das propostas mais interessantes do Security Hub Extended é a integração entre os próprios parceiros do programa. Um cliente que já usa outras soluções do Extended pode combiná-las sem precisar construir integrações manualmente.

    Um exemplo concreto mencionado pela AWS: um cliente que usa Chainguard para segurança da cadeia de suprimentos de software, Upwind para proteção em runtime e Splunk para operações de segurança obtém uma experiência conectada. A Chainguard garante dependências limpas e resistentes a malware na fase de build. A Upwind valida o comportamento das cargas de trabalho em tempo de execução e enriquece os achados com contexto em tempo real. Tudo flui para o Splunk via Security Hub para triagem unificada — uma fatura, sem trabalho de integração customizada.

    O mesmo padrão se aplica com o 7AI, onde automação baseada em IA pode fazer triagem e investigação de eventos de runtime da Upwind junto com sinais de endpoint, identidade e rede, sem trabalho manual de pipeline.

    Os achados fluem pelo Security Hub no formato OCSF (Open Cybersecurity Schema Framework — Estrutura de Esquema Aberto para Cibersegurança), são correlacionados e priorizados em conjunto, e roteados para as ferramentas que a equipe já utiliza.

    Como funciona comercialmente

    A AWS destaca que não se trata de uma parceria apenas no papel. Negócios de múltiplos milhões de dólares já foram fechados por meio do Security Hub Extended com a Upwind.

    Um caso mencionado: uma empresa enterprise substituiu sua solução anterior de CNAPP (Plataforma de Proteção de Aplicações Nativas de Nuvem) pela Upwind por meio de uma Private Offer do Security Hub Extended. Os fatores decisivos foram a visibilidade em runtime que a solução anterior não entregava e um modelo comercial previsível que substituiu a precificação complexa por módulo de múltiplos fornecedores.

    A Upwind está disponível no Security Hub Extended com:

    • Precificação pay-as-you-go
    • Cobrança unificada na fatura AWS
    • Sem compromisso de longo prazo obrigatório
    • Opção de Private Offers para empresas que preferem contratos com preços comprometidos e descontos maiores, com possibilidade de agregar gastos entre parceiros

    O que a Upwind está construindo a seguir

    A AWS também compartilhou o roadmap de expansão da Upwind dentro do programa:

    • Proteção de cargas de trabalho de IA: monitoramento do comportamento de modelos e chamadas de ferramentas de agentes em tempo de execução.
    • Cobertura de VMs Windows Server na AWS, Azure e GCP.
    • Integração mais profunda com o mecanismo de correlação do Security Hub, para que o contexto de runtime enriqueça automaticamente a inteligência de caminhos de ataque.

    O que isso significa na prática

    Para quem já usa o Security Hub para gerenciamento de postura e varredura de vulnerabilidades, adicionar a Upwind significa ganhar visibilidade em runtime sem precisar configurar novas ferramentas ou aprender novos fluxos de trabalho. A solução aparece na visão priorizada de riscos que o time já conhece.

    A Upwind pode ser habilitada diretamente pelo console do AWS Security Hub, com precificação pay-as-you-go e sem compromisso inicial. Para entender como consolidar o stack de segurança com o Security Hub Extended, a recomendação é conversar com o time de conta AWS.

    Fonte

    We invited a direct competitor into Security Hub Extended. Here’s why. (https://aws.amazon.com/blogs/security/we-invited-a-direct-competitor-into-security-hub-extended-heres-why/)

  • Automatize a governança do IAM Identity Center com descoberta contínua e relatórios

    O desafio de governar identidades em escala na AWS

    O AWS IAM Identity Center é o ponto central de autenticação e autorização para recursos AWS dentro de uma organização. Ele se integra ao provedor de identidade externo (IdP) da empresa e ao AWS Organizations, além de suportar um número crescente de serviços AWS com integração nativa.

    À medida que a organização cresce, manter visibilidade sobre quem acessa o quê — e garantir que as políticas de governança sejam aplicadas de forma consistente em todas as contas e regiões — se torna progressivamente mais complexo. O Identity Center centraliza autenticação e autorização, mas rastrear atribuições de acesso e fazer cumprir políticas de segurança em escala é um desafio próprio.

    A AWS publicou uma solução de exemplo que automatiza a descoberta e o reporte dessas atribuições, ajudando equipes de segurança e governança a responder perguntas como:

    • Quais usuários ou grupos têm acesso a quais aplicações AWS?
    • Quem acessou determinada aplicação pela última vez e quando?
    • Quais usuários e grupos estão atribuídos a aplicações do Identity Center em toda a organização e regiões?
    • Como gerar relatórios rapidamente para auditorias de conformidade ou revisões de segurança?

    Planejando a governança de identidades para atribuições de aplicações

    Antes de implementar qualquer automação, a AWS recomenda alinhar quatro áreas fundamentais, envolvendo equipes de segurança, governança, aplicações e negócios:

    • Quem pode provisionar aplicações gerenciadas: As restrições de criação de recursos AWS nas contas da organização devem ser implementadas via políticas de identidade IAM, Políticas de Controle de Serviço (SCP), Políticas de Controle de Recursos (RCP) ou ferramentas de avaliação de políticas como Open Policy Agent (OPA) ou Checkov.
    • Quem gerencia atribuições de usuários e grupos: O administrador da aplicação gerenciada cuida da autorização dentro de uma conta AWS. É recomendado definir claramente papéis e responsabilidades ao longo do fluxo de trabalho.
    • Como o fluxo de autenticação ocorre do IdP aos recursos AWS: Usuários se autenticam no Identity Center, são autorizados a acessar aplicações gerenciadas e, a partir daí, acessam os serviços e recursos AWS associados.
    • Mapeamento de identidades do IdP ao acesso em recursos AWS: É preciso estabelecer a ligação entre usuários e grupos no IdP, as aplicações gerenciadas no Identity Center e os recursos e permissões downstream. A Propagação de Identidade Confiável (TIP) é um recurso adicional do Identity Center que fornece rastreabilidade completa da identidade até o serviço downstream.

    Criando e gerenciando o ciclo de vida de atribuições de aplicações

    Como boa prática de segurança, a AWS recomenda habilitar a administração delegada ao gerenciar o Identity Center em instâncias de organização AWS. Após configurar o IAM Identity Center em uma instância de organização, as contas-membro podem criar recursos AWS associados. Para isso, os principais IAM que provisionam recursos precisam de dois tipos de permissões IAM específicas:

    • Permissões específicas do serviço AWS: Por exemplo, para criar um domínio do Amazon SageMaker AI, são necessárias as permissões habituais de criação do domínio e dos recursos downstream que o SageMaker AI utiliza.
    • Permissões específicas do IAM Identity Center: O principal IAM usado para criar o recurso também precisa de permissões para gerenciar aplicações dentro da instância do Identity Center.

    Um exemplo de política IAM para criação e gerenciamento de aplicações no Identity Center:

    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Effect": "Allow",
          "Action": [
            "sso:CreateManagedApplicationInstance",
            "sso:GetManagedApplicationInstance",
            "sso:DeleteManagedApplicationInstance",
            "sso:DescribeRegisteredRegions"
          ],
          "Resource": "*"
        },
        {
          "Effect": "Allow",
          "Action": [
            "sso:CreateApplication",
            "sso:DescribeApplication",
            "sso:DeleteApplication",
            "sso:PutApplicationGrant",
            "sso:PutApplicationAuthenticationMethod",
            "sso:PutApplicationAccessScope"
          ],
          "Resource": [
            "arn:aws:sso::<INSERT-ACCOUNT-ID>:application/ssoins-<INSERT-INSTANCE-ID>/apl-*"
          ]
        }
      ]
    }

    Um ponto importante: os Nomes de Recurso Amazon (ARN) de aplicações do Identity Center usam identificadores únicos (GUIDs) gerados no momento da criação, diferente de recursos como buckets do Amazon Simple Storage Service (Amazon S3), cujo nome aparece diretamente no ARN.

    Gerenciando acesso a uma aplicação do Identity Center

    Após criar a aplicação, é necessário gerenciar o acesso a ela. Dois tipos de permissões IAM são necessários:

    1. Permissões para listar usuários e grupos do Identity Center:

    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "ListIdentityCenterUsers",
          "Effect": "Allow",
          "Action": [
            "identitystore:ListUsers",
            "identitystore:DescribeUser",
            "identitystore:ListGroups",
            "identitystore:DescribeGroup",
            "identitystore:ListGroupMemberships"
          ],
          "Resource": "*"
        }
      ]
    }

    Vale notar que as ações de listagem exigem acesso a AllUsers ou AllGroups, o que significa que uma política IAM restritiva não pode impedir que um principal veja um subconjunto de usuários ou grupos no identity store.

    2. Permissões para criar e gerenciar atribuições de aplicações:

    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "ManageApplicationAssignments",
          "Effect": "Allow",
          "Action": [
            "sso:CreateApplicationAssignment",
            "sso:DeleteApplicationAssignment",
            "sso:ListApplicationAssignments",
            "sso:PutApplicationAssignmentConfiguration"
          ],
          "Resource": [
            "arn:aws:sso::<INSERT-ACCOUNT-ID>:application/ssoins-<INSERT-INSTANCE-ID>/apl-*"
          ]
        }
      ]
    }

    Como o ARN da aplicação do Identity Center usa um ID único gerado na criação, não é recomendado implementar políticas IAM que restrinjam principais autorizados a gerenciar aplicações específicas do Identity Center por ARN. Em vez disso, a recomendação é limitar o gerenciamento de aplicações e atribuições a um número reduzido de principais IAM autorizados, complementado por capacidades de detecção e resposta.

    Planejando convenções de nomenclatura e estratégia de automação

    O IAM Identity Center disponibiliza diversas APIs para capturar informações sobre instâncias, aplicações e atribuições na organização. Antes de implementar automação ou guardrails, é importante definir uma abordagem metódica. A AWS sugere:

    • Convenção para grupos no IdP: Ex.: AWS_<ACCT#>_<AWS_Service>_<LOB>_<ENV>_<AppName> → AWS_123412341234_SageMaker_Data_PROD_GTLabel
    • Convenção para recursos AWS integrados ao Identity Center: Ex.: <AWS_Service>_<LOB>_<AppName> → SageMaker_Data_GTLabel
    • Convenção para nomes de aplicações no Identity Center: Ex.: <AWS_Service>_<LOB>_<ENV>_<AppName> → SageMaker_Data_PROD_GTLabel

    Também é importante decidir quais partes do fluxo serão centralizadas — criação de aplicações, atribuições ou remediação de problemas. Centralizar demais pode criar gargalos; descentralizar demais aumenta o risco de atribuições fora dos padrões de segurança corporativos. O equilíbrio certo depende do contexto de cada organização.

    Para localizar o ARN de uma aplicação do Identity Center a partir de um recurso AWS específico (como um domínio SageMaker AI), uma busca reversa é necessária, pois os serviços AWS criam aplicações Identity Center com ARNs baseados em GUID que não são facilmente descobertos. Veja o exemplo em shell:

    #!/bin/bash
    DOMAIN_ID="d-xxxxxxxxxxxx"
    REGION="xx-xxxx-x"
    
    # Step 1: Get SageMaker domain details
    echo "=== SageMaker Domain Details ==="
    DOMAIN_INFO=$(aws sagemaker describe-domain \
      --region $REGION \
      --domain-id $DOMAIN_ID)
    
    # Step 2: Extract Identity Center application ARN
    SSO_APP_ARN=$(echo $DOMAIN_INFO | jq -r '.SingleSignOnApplicationArn')
    echo "Identity Center App ARN: $SSO_APP_ARN"

    A solução de automação: descoberta e relatórios

    A solução de exemplo sample-iam-idc-application-discovery-reporting, disponível no GitHub, é composta por duas stacks separadas do AWS Cloud Development Kit (AWS CDK):

    • Stack de relatórios de governança (/identity-center-reporting): fornece descoberta automatizada e geração de relatórios em CSV.
    • Stack de remediação (/identity-center-remediation): fornece aplicação de políticas em tempo real e notificações.

    A recomendação é implantar primeiro a stack de relatórios para estabelecer visibilidade de baseline, e depois a stack de remediação para aplicação de políticas.

    Recursos implantados pela stack de relatórios

    • Amazon EventBridge: regra que invoca o fluxo de descoberta diariamente às 2h UTC (configurável).
    • AWS Step Functions: orquestra o fluxo de descoberta em múltiplos estágios — instâncias, aplicações e atribuições.
    • AWS Lambda: realiza a descoberta de instâncias do Identity Center, enumera aplicações e mapeia usuários e grupos a aplicações, resolvendo nomes amigáveis do Identity Store.
    • Amazon DynamoDB: armazena instâncias, aplicações e atribuições descobertas, criptografadas com chave gerenciada pelo cliente via AWS Key Management Service (AWS KMS).
    • Amazon API Gateway: fornece uma API REST autenticada via IAM para geração e exportação de relatórios como arquivos CSV.
    • Amazon S3: armazena as exportações CSV criptografadas, com políticas de ciclo de vida e URLs pré-assinadas com tempo limitado para download.

    Pré-requisitos e implantação da stack de relatórios

    Para implantar a solução, são necessários:

    • Uma organização AWS com instância do IAM Identity Center e administração delegada configurada.
    • IAM Identity Center configurado com ao menos uma instância.
    • Interface de Linha de Comando AWS (AWS CLI) configurada com credenciais adequadas.
    • Python 3.12 e Node.js 18 ou superior instalados para o deploy com CDK.

    Comandos para implantação:

    git clone https://github.com/aws-samples/sample-iam-idc-application-discovery-reporting
    cd identity-center-reporting
    
    python3.12 -m venv .venv && source .venv/bin/activate
    pip install -r requirements.txt
    
    cdk bootstrap aws://<INSERT-ACCOUNT-ID>/<INSERT-REGION>
    
    export IDC_EXTERNAL_ID="$(uuidgen)"
    cdk deploy --parameters AllowedIpRange=10.0.0.0/8 --parameters CrossAccountExternalId="$IDC_EXTERNAL_ID"

    O parâmetro AllowedIPRange é opcional, mas recomendado como boa prática de segurança — ele adiciona uma restrição de rede ao download da URL pré-assinada do Amazon S3. Para descoberta de instâncias Identity Center em nível de conta AWS, é necessária uma função IAM entre contas:

    python scripts/deploy-cross-account-roles.py --external-id "$IDC_EXTERNAL_ID"

    Após o deploy, a automação roda em agendamento diário. A primeira execução de descoberta ocorre imediatamente após a implantação. É possível monitorar o histórico de execuções pelo console do AWS Step Functions, revisar logs detalhados no Amazon CloudWatch Logs e consultar instâncias, aplicações e atribuições descobertas diretamente no console do DynamoDB.

    Gerando relatórios de atribuições

    Para gerar relatórios sob demanda como arquivos CSV via API REST:

    export AWS_REGION="<REPLACE-REGION>"
    export API_ID="<REPLACE-API-ID>"
    eval "$(aws configure export-credentials --profile "<YOUR-PROFILE>" --format env)"
    
    # Exportar aplicações
    curl -sS --fail-with-body \
      --aws-sigv4 "aws:amz:${AWS_REGION}:execute-api" \
      --user "${AWS_ACCESS_KEY_ID}:${AWS_SECRET_ACCESS_KEY}" \
      --header "x-amz-security-token: ${AWS_SESSION_TOKEN}" \
      "https://${API_ID}.execute-api.${AWS_REGION}.amazonaws.com/prod/export/applications" \
      -o applications.json
    
    # Exportar atribuições com nomes de usuários e grupos
    curl -sS --fail-with-body \
      --aws-sigv4 "aws:amz:${AWS_REGION}:execute-api" \
      --user "${AWS_ACCESS_KEY_ID}:${AWS_SECRET_ACCESS_KEY}" \
      --header "x-amz-security-token: ${AWS_SESSION_TOKEN}" \
      "https://${API_ID}.execute-api.${AWS_REGION}.amazonaws.com/prod/export/assignments" \
      -o assignments.json

    A API retorna um JSON com uma URL pré-assinada do Amazon S3 válida por 15 minutos. Os arquivos CSV gerados incluem dados enriquecidos com nomes amigáveis, como ARN da instância, ID da conta, nome da aplicação, tipo de principal, nome do principal e status. Com esses dados, é possível identificar anomalias ou atribuições não conformes — por exemplo, uma aplicação de produção que deveria ter apenas atribuições de grupo, mas possui um usuário individual atribuído.

    Stack de remediação: monitoramento e resposta em tempo real

    A stack de remediação complementa os relatórios com aplicação de políticas em tempo real. Os recursos implantados incluem:

    • Amazon EventBridge: captura eventos de atribuição e perfil do IAM Identity Center via CloudTrail (sso.amazonaws.com) para ações como CreateApplicationAssignment, DeleteApplicationAssignment, PutApplicationAssignmentConfiguration, AssociateProfile, DisassociateProfile, CreateProfile, UpdateProfile e DeleteProfile.
    • AWS Lambda: resolve nomes de aplicações e grupos, valida a atribuição contra a convenção de nomenclatura e notifica ou remedia conforme o modo configurado.
    • Amazon Simple Notification Service (Amazon SNS): publica alertas de atribuições não conformes para assinantes (como e-mail).
    • Amazon Simple Queue Service (Amazon SQS): captura eventos que a função Lambda não conseguiu processar para inspeção posterior.
    • AWS KMS: chave gerenciada pelo cliente para criptografar variáveis de ambiente do Lambda, logs do CloudWatch, tópico SNS e fila de mensagens mortas.
    • Amazon CloudWatch: grupo de logs armazena os logs estruturados e criptografados da função como trilha de auditoria.

    As políticas de nomenclatura suportam correspondência por expressões regulares (regex) para requisitos organizacionais específicos.

    Implantação da stack de remediação

    git clone https://github.com/aws-samples/sample-iam-idc-application-discovery-reporting
    cd identity-center-remediation
    cdk deploy --context enableAutoDeletion=false --parameters IdentityCenterInstanceArn=arn:aws:sso:::instance/ssoins-<INSERT-ORG-INSTANCE-ID> --parameters ManagementAccountId=<INSERT-MANAGEMENT-ACCOUNT>

    Por padrão, a solução verifica se o nome do grupo aparece como palavra completa no nome da aplicação (sem distinção entre maiúsculas e minúsculas, separando por -, _ e espaços). Assim, ReadOnly corresponde a sagemaker_readonly, mas read não corresponde. Para casos de uso diferentes, o parâmetro GroupNameRegex pode ser passado durante o deploy.

    Testando atribuições conformes e não conformes

    Para obter as informações necessárias do ambiente:

    INSTANCE_ARN=$(aws sso-admin list-instances --region <REPLACE-REGION> --query "Instances[0].InstanceArn" --output text)
    echo "$INSTANCE_ARN"
    
    IDENTITY_STORE_ID=$(aws sso-admin list-instances --region <REPLACE-REGION> --query "Instances[0].IdentityStoreId" --output text)
    echo "$IDENTITY_STORE_ID"
    
    aws identitystore list-groups --identity-store-id $IDENTITY_STORE_ID --query "Groups[].{Name:DisplayName,Id:GroupId}" --output table
    
    aws sso-admin list-applications --instance-arn $INSTANCE_ARN --query "Applications[?Status=='ENABLED'].{Name:Name,ARN:ApplicationArn}" --output table

    Definindo variáveis para os grupos e aplicação de teste:

    export GRP_READONLY=abc12345-1234-1234-1234-abcdef123456
    export GRP_DEVELOPER=abc12345-1234-1234-1234-abcdef123457
    export APP_READONLY="arn:aws:sso::<INSERT-ACCOUNT-ID>:application/<INSERT-INSTANCE-ARN>/<INSERT-APPLICATION-ARN>"

    Atribuição conforme — adicionando o grupo ReadOnly à aplicação sagemaker_readonly:

    aws sso-admin create-application-assignment --application-arn $APP_READONLY --principal-id $GRP_READONLY --principal-type GROUP

    O log da função Lambda mostrará:

    ✓ COMPLIANT - Group name found in application name applicationName="sagemaker_readonly" groupName="ReadOnly"
    Remediation action determined: NONE

    Atribuição não conforme — tentando adicionar o grupo Developer à aplicação sagemaker_readonly:

    aws sso-admin create-application-assignment --application-arn $APP_READONLY --principal-id $GRP_DEVELOPER --principal-type GROUP

    O log mostrará:

    ✗ NON-COMPLIANT - Group name not found in application name applicationName="sagemaker_readonly" groupName="Developer"
    Remediation action determined: NOTIFICATION_ONLY
    SNS notification sent successfully

    Com enableAutoDeletion=false, a solução apenas notifica. Para que a atribuição seja removida automaticamente, o valor deve ser alterado para enableAutoDeletion=true. A mensagem SNS enviada inclui detalhes como tipo de evento, nome da aplicação, nome do grupo, ação tomada, ARN da aplicação e quem iniciou a ação.

    Governança IAM em escala: um framework de alto nível

    A AWS sugere os seguintes passos de alto nível para estruturar a governança do Identity Center com essas soluções:

    • Implantar a automação com um principal IAM que tenha acesso na conta de administrador delegado.
    • Estabelecer uma baseline executando a primeira descoberta e revisando os relatórios gerados.
    • Configurar políticas de nomenclatura alinhadas às convenções de segurança da organização.
    • Implantar o monitoramento orientado a eventos para habilitar aplicação de políticas em tempo real.
    • Começar no modo de notificação para validar as políticas antes de habilitar a auto-remediação.
    • Integrar com ferramentas de governança conectando os endpoints da API a dashboards de conformidade ou ferramentas de ITSM.
    • Migrar para auto-remediação após validar que as políticas estão funcionando conforme esperado.

    Os relatórios agendados fornecem visibilidade de baseline sobre as aplicações gerenciadas pelo IAM Identity Center. O monitoramento orientado a eventos entrega notificações ou aplicação de políticas em tempo quase real. Juntas, essas soluções ajudam a alinhar e escalar o Identity Center com os padrões de governança e segurança da organização — por meio de análise histórica e resposta imediata.

    Limpeza do ambiente

    Para remover as stacks implantadas, execute os seguintes comandos nas respectivas contas AWS:

    # Remover a stack de remediação
    cd sample-iam-idc-application-discovery-reporting/identity-center-remediation
    cdk destroy
    
    # Remover a stack de relatórios
    cd sample-iam-idc-application-discovery-reporting/identity-center-reporting
    cdk destroy

    Fonte

    Automate IAM Identity Center governance with continuous discovery and reporting (https://aws.amazon.com/blogs/security/automate-iam-identity-center-governance-with-continuous-discovery-and-reporting/)

  • AWS Transform agora está em conformidade com o FedRAMP Classe C

    O que mudou

    A AWS anunciou que o AWS Transform agora está dentro do escopo do Programa Federal de Gerenciamento de Risco e Autorização (FedRAMP) — especificamente na classificação Classe C (anteriormente conhecida como baseline Moderada), na região US East (Ohio).

    Na prática, isso significa que organizações sujeitas aos requisitos de conformidade do FedRAMP Classe C já podem utilizar o AWS Transform para construir aplicações e executar cargas de trabalho dentro desse padrão regulatório.

    O que é o FedRAMP

    O FedRAMP é um programa do governo dos Estados Unidos que estabelece uma abordagem padronizada para avaliação de segurança, autorização e monitoramento contínuo de produtos e serviços em nuvem. Ele é exigido para fornecedores de tecnologia que atendem agências federais norte-americanas, funcionando como um selo de conformidade rigoroso no setor público americano.

    Para saber quais serviços da AWS já estão dentro do escopo do FedRAMP, a AWS mantém uma página de serviços em conformidade atualizada.

    O que é o AWS Transform

    O AWS Transform é um serviço de migração e modernização com capacidades agênticas — ou seja, ele age de forma autônoma para conduzir processos complexos com menos intervenção manual. O objetivo declarado do serviço é comprimir cronogramas corporativos que normalmente levariam anos para algo na casa de meses.

    Entre as capacidades do serviço estão:

    • Migrações de infraestrutura em larga escala
    • Redução contínua de débito técnico
    • Eliminação das transferências manuais e da perda de contexto que costumam travar esses programas

    Por que isso importa

    A certificação FedRAMP é um requisito crítico para qualquer serviço de nuvem utilizado no setor público americano. Ao atingir o nível Classe C no AWS Transform, a AWS amplia as possibilidades de adoção do serviço por órgãos governamentais e contratados federais nos EUA que precisam garantir conformidade regulatória em seus projetos de modernização.

    Para equipes brasileiras que atendem clientes ou parceiros no mercado americano — especialmente no setor público —, essa é uma informação relevante para avaliar o uso do AWS Transform em projetos com requisitos de compliance federal.

    Saiba mais

    Para aprofundar o conhecimento sobre o serviço, a AWS disponibiliza a página oficial do AWS Transform e a documentação técnica completa.

    Fonte

    AWS Transform now in scope for FedRAMP Class C (https://aws.amazon.com/about-aws/whats-new/2026/08/aws-transform-fedramp-class-c/)

  • AWS Management Console Private Access: acesso sem internet para ambientes isolados

    O problema que a AWS resolveu

    Organizações em setores regulados como serviços financeiros, governo, defesa e saúde costumam restringir suas cargas de trabalho a ambientes de rede isolados, sem qualquer acesso à internet pública. Até recentemente, havia uma tensão clara nesse modelo: era possível restringir o acesso ao AWS Management Console a contas e redes corporativas autorizadas, mas o console em si ainda exigia conectividade com a internet para funcionar completamente.

    Isso colocava as equipes de segurança diante de uma escolha difícil — permitir alguma saída para a internet para usar o console, ou negar o acesso ao console para operadores que trabalham em ambientes completamente isolados.

    A AWS anunciou a disponibilidade geral do AWS Management Console Private Access com suporte a Nuvens Privadas Virtuais (VPCs) sem conectividade com a internet. Agora, todo o tráfego dos consoles de serviço suportados — fluxos de autenticação, assets estáticos (JavaScript, CSS, imagens), APIs exclusivas do console e chamadas às APIs de serviços AWS — pode ser roteado por endpoints de VPC via AWS PrivateLink, eliminando a necessidade de internet gateway, NAT gateway ou qualquer rota para a internet pública. O recurso está disponível em todas as Regiões comerciais da AWS para um conjunto selecionado de consoles de serviço suportados.

    O que mudou em relação ao lançamento anterior

    Em 2023, a AWS lançou a primeira versão do Console Private Access, que já permitia rotear chamadas de console, sign-in e APIs de serviço por endpoints de VPC. No entanto, os assets estáticos e as APIs exclusivas do console ainda dependiam de conectividade com a internet. Esse gap foi eliminado com este lançamento.

    Dois cenários principais atendidos

    Tráfego do console em redes sem acesso à internet

    Com a atualização, o tráfego dos consoles de serviço suportados flui inteiramente pelos endpoints de VPC — sem listas de domínios permitidos para manter, sem proxies interceptando TLS e sem a necessidade de aceitar fluxos exclusivamente via CLI como solução de contorno. O mesmo caminho funciona a partir do Amazon WorkSpaces, instâncias do Amazon Elastic Compute Cloud (Amazon EC2) e redes on-premises conectadas via AWS Direct Connect ou AWS Site-to-Site VPN.

    Combinando com Políticas de Controle de Recursos (RCPs) de sign-in e políticas de recursos de sign-in, é possível garantir que a autenticação no console só seja bem-sucedida a partir de redes esperadas — mesmo que credenciais válidas sejam apresentadas de outro lugar, a sessão é negada.

    Prevenção de exfiltração de dados

    O Private Access também permite restringir quais contas AWS e identidades organizacionais podem usar o AWS Management Console a partir da VPC. Isso impede o acesso via contas pessoais ou contas fora da organização. Ao anexar uma política de endpoint de VPC com a condição aws:ResourceOrgID, as ações do console ficam automaticamente limitadas a recursos dentro da organização. As RCPs de sign-in adicionam uma segunda camada, garantindo que a autenticação só funcione a partir de redes dentro do perímetro.

    Como o tráfego flui em um ambiente sem internet

    O Console Private Access utiliza três endpoints de VPC distintos para cobrir todo o tráfego necessário:

    • Fluxos de autenticação — sign-in, troca de credenciais e requisições de token de sessão
    • Assets estáticos — JavaScript, CSS e imagens que renderizam a interface do console
    • Chamadas de API do console de serviço — as requisições de backend feitas quando usuários interagem com os consoles de serviço

    O fluxo completo a partir de uma carga de trabalho em uma VPC privada funciona assim: o navegador do operador requisita <região>.console.aws.amazon.com; o encaminhador de DNS corporativo repassa a consulta para um endpoint de entrada do Amazon Route 53 Resolver configurado na VPC, que encaminha o tráfego para o endpoint de VPC do console. O tráfego flui de on-premises via Direct Connect (ou AWS Site-to-Site VPN) até a VPC, e o endpoint de VPC roteia o tráfego para o serviço do console pela rede privada da AWS. O console redireciona para o endpoint de sign-in, que avalia as políticas de endpoint de VPC, políticas baseadas em recursos (RBPs) e RCPs antes de redirecionar de volta ao console. Por fim, o console carrega o conteúdo estático pelo endpoint de VPC do console-static e aplica as restrições de identidade e recurso ao fazer chamadas às APIs dos serviços AWS.

    Controles de perímetro de dados aplicados ao console

    O Console Private Access e as políticas de recursos de sign-in são uma extensão natural das Políticas de Controle de Serviço (SCPs), RCPs e políticas de endpoint de VPC que as equipes já utilizam para tráfego de API. Agora, os mesmos controles de perímetro de dados para identidade, recurso e rede que protegem o acesso programático também protegem as sessões interativas do navegador.

    A tabela de controles cobre quatro objetivos principais:

    • Identidade: Apenas identidades confiáveis podem acessar recursos — via RCPs e RBPs de sign-in, restringindo quais principals podem autenticar no console usando condições como aws:PrincipalOrgID, aws:PrincipalAccount e aws:PrincipalArn.
    • Recurso: Identidades só podem acessar recursos confiáveis — via SCP com aws:ResourceOrgID, que segue os principals em cada sessão do console e nega chamadas de API cujo recurso-alvo esteja fora da organização.
    • Rede (identidade): Identidades só acessam recursos a partir de redes esperadas — via SCPs de perímetro de rede com aws:SourceVpc. Com o Private Access, requisições enviadas pelo console aos serviços suportados carregam aws:SourceVpc definido para a VPC que hospeda os endpoints.
    • Rede (recurso): Recursos só podem ser acessados a partir de redes esperadas — via RBPs e RCPs de sign-in que negam autenticação no console a partir de redes inesperadas, usando condições como aws:SourceIp, aws:SourceVpc, aws:SourceVpce e aws:VpcSourceIp.

    Guia de implantação passo a passo

    A AWS recomenda um rollout incremental, validando cada etapa antes de expandir para Regiões e Unidades Organizacionais (OUs) adicionais. Para quem quiser validar a mecânica antes de construir a solução completa, o guia de início rápido com ambiente de teste apresenta uma configuração mínima com uma única VPC, os três endpoints e uma política permissiva.

    Pré-requisitos

    Passo 1: Mapear o acesso atual ao console

    Antes de qualquer mudança, use o CloudTrail para mapear como os usuários acessam o console hoje. Busque por eventName = ConsoleLogin em uma janela representativa (recomenda-se 30 dias) e revise os campos sourceIPAddress, vpcEndpointId e awsRegion. Identifique quais tipos de identidade estão em uso: usuário root, usuário IAM, federação SAML e AWS IAM Identity Center. Escolha a OU ou conta que será usada no piloto — evite contas de produção ou compartilhadas.

    Passo 2: Criar os endpoints de VPC do Private Access

    Na Região escolhida, crie ou identifique uma VPC para hospedar os endpoints e, em seguida, crie três endpoints de interface de VPC nessa VPC:

    • com.amazonaws.<região>.console — para o console
    • com.amazonaws.<região>.signin — para o AWS Sign-In
    • com.amazonaws.<região>.console-static — para APIs exclusivas do console (obrigatório apenas se a VPC não tiver caminho para a internet)

    Passo 3: Configurar o DNS privado

    Para cargas de trabalho dentro da VPC que usam o Amazon Route 53 Resolver padrão, nenhuma configuração adicional de DNS é necessária — basta habilitar o nome de DNS privado em cada endpoint (PrivateDnsEnabled = true). Se você usar um resolver de DNS customizado ou uma zona hospedada privada, é necessário configurá-lo explicitamente para mapear os domínios do console para os endereços dos endpoints. Consulte a documentação de zonas hospedadas privadas e a documentação de endpoints obrigatórios do Console Private Access para a lista completa de domínios.

    Para cargas de trabalho fora da VPC — como escritórios corporativos conectados via Direct Connect ou Site-to-Site VPN — garanta que o resolver de DNS corporativo retorne os endereços dos endpoints para esses domínios. O post Simplify DNS management in a multi-account environment with Route 53 Resolver traz orientações detalhadas.

    Passo 4: Verificar a conectividade privada

    Faça login no console a partir de uma carga de trabalho dentro da VPC. Para confirmar que o tráfego está roteando pelos endpoints de VPC, verifique o ícone de cadeado na barra de navegação do console. Você também pode confirmar no CloudTrail que eventos recentes de ConsoleLogin mostram o campo vpcEndpointId preenchido com um dos seus IDs de endpoint. Veja um exemplo de evento:

    {
      "eventVersion": "1.08",
      "userIdentity": {
        "type": "AssumedRole",
        "principalId": "AROA3XFRBF23EXAMPLE:john.doe",
        "arn": "arn:aws:sts::123456789012:assumed-role/Admin/john.doe",
        "accountId": "123456789012"
      },
      "eventTime": "2026-07-08T19:15:32Z",
      "eventSource": "signin.amazonaws.com",
      "eventName": "ConsoleLogin",
      "awsRegion": "us-east-1",
      "sourceIPAddress": "10.0.1.47",
      "userAgent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)...",
      "requestParameters": null,
      "responseElements": {
        "ConsoleLogin": "Success"
      },
      "additionalEventData": {
        "LoginTo": "https://console.aws.amazon.com/console/home",
        "MobileVersion": "No",
        "MFAUsed": "Yes",
        "vpcEndpointId": "vpce-0abc123def456789a"
      },
      "eventID": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
      "eventType": "AwsConsoleSignIn",
      "recipientAccountId": "123456789012"
    }

    Se o console não carregar, verifique: se o DNS privado está habilitado em cada endpoint; se os grupos de segurança dos endpoints permitem HTTPS (TCP 443) das sub-redes das cargas de trabalho; e se, para tráfego externo à VPC, o DNS corporativo retorna os IPs privados dos endpoints. Para validação end-to-end, execute traceroute console.aws.amazon.com a partir da sua estação de trabalho e confirme que o caminho usa apenas hops privados.

    Passo 5: Aplicar políticas de endpoint de VPC

    Anexe uma política de endpoint nos endpoints do console e do AWS Sign-In que limite o acesso a identidades da sua organização. Comece com uma política permissiva Allow * e confirme que o tráfego está roteando pelos endpoints. Depois, adicione restrições usando as condições aws:PrincipalOrgID e aws:ResourceOrgID. A referência completa está no guia do usuário do Console Private Access. Para políticas além do piloto, consulte Data perimeters on AWS e o repositório de exemplos de políticas de perímetro de dados no GitHub.

    Passo 6: Aplicar uma política de Sign-In

    As políticas de Sign-In negam requisições de autenticação no console que não correspondam às condições de rede ou de principal definidas. A política é composta por uma instrução de pré-autenticação cobrindo signin:Authenticate e uma instrução de pós-autenticação cobrindo signin:AuthorizeOAuth2Access e signin:CreateOAuth2Token — inclua ambas.

    Para o piloto, implante a política como uma RCP a partir da conta de gerenciamento do AWS Organizations. Como a RCP se aplica a todas as contas da organização, recomenda-se pilotar em uma organização de teste dedicada antes de expandir. Ative a aplicação chamando a API signin:PutConsoleAuthorizationConfiguration para a organização na Região us-east-1.

    Importante: Configure pelo menos um principal excluído como caminho de acesso emergencial (break-glass) antes de habilitar a RCP. O principal recomendado é uma role IAM dedicada.

    Exemplo — Restringir acesso à VPC corporativa:

    aws signin put-resource-permission-statement \
      --source-vpc vpc-0abc123def456789 \
      --requested-region us-west-2 \
      --excluded-principal "arn:aws:iam::123456789012:user/EmergencyAdmin" \
      --region us-east-1

    Exemplo — Restringir acesso a um intervalo de IP específico:

    aws signin put-resource-permission-statement \
      --source-ip "IP_ADDRESS" \
      --excluded-principal "arn:aws:iam::123456789012:role/BreakGlassRole" \
      --region us-east-1

    Habilitar a autorização do console para a organização:

    aws signin put-console-authorization-configuration \
      --target-id <your-target-id> \
      --region us-east-1

    Para exemplos de políticas, referência da Interface de Linha de Comando da AWS (AWS CLI) e o procedimento de recuperação em caso de bloqueio, consulte o post sobre RBPs de sign-in e a documentação de controle de acesso ao console com políticas baseadas em recursos.

    Passo 7: Adicionar endpoints de VPC para cada serviço

    Os endpoints do Private Access carregam o shell do console, mas não as chamadas de API de serviço que o console faz em nome do usuário. Em uma VPC sem internet gateway, essas chamadas não têm para onde ir. Por isso, é necessário adicionar um endpoint de VPC para cada serviço utilizado.

    Para o piloto, crie um endpoint de interface do AWS KMS (com.amazonaws.<região>.kms) na mesma VPC, com DNS privado habilitado, e confirme que a lista de chaves carrega ao acessar o console do AWS Key Management Service (AWS KMS) de dentro da VPC. Repita para cada serviço necessário. A lista atual de serviços que suportam PrivateLink está na documentação do AWS PrivateLink. Consoles de serviços que não suportam PrivateLink não funcionarão em VPCs sem internet e precisam ser tratados separadamente.

    Passo 8: Ocultar Regiões e serviços não configurados (opcional)

    Links do console para serviços ou Regiões sem endpoints configurados falharão dentro da VPC. Para evitar que usuários naveguem para páginas quebradas, use a Personalização de Experiência do Usuário (UXC) para ocultar Regiões e serviços que não fazem parte da implantação do Private Access. A UXC é configurada no nível da conta e se aplica à navegação, resultados de busca e menus de seleção de serviços.

    Passo 9: Validar e expandir

    Após aplicar as políticas de endpoint e a RCP de Sign-In a uma conta piloto, valide dois cenários: login de dentro da rede corporativa (deve ter sucesso) e login de fora da rede corporativa (deve ser negado na etapa de Sign-In, antes de chegar ao console). No CloudTrail, confirme que os eventos ConsoleLogin mostram vpcEndpointId preenchido para tráfego de dentro da rede. Para negações inesperadas, procure eventos ConsoleLogin com as mensagens de erro Authorization denied because of a resource-based policy ou Authorization denied because of a resource control policy.

    Considerações importantes

    • IAM Identity Center: O suporte ao sign-in via IAM Identity Center ainda não está disponível por endpoint de VPC. A autenticação inicial de Single Sign-On (SSO) ainda precisa transitar pela internet.
    • Acesso programático: RBPs e RCPs de Sign-In controlam o sign-in interativo no console. Requisições do AWS SDK e da AWS CLI assinadas com SigV4 não são afetadas. Esse também é o caminho de recuperação: um principal com permissão signin:DeleteConsoleAuthorizationConfiguration pode desabilitar a aplicação programaticamente se a autorização do console estiver mal configurada.
    • Aplicações integradas ao AWS Sign-In: As políticas de Sign-In também se aplicam ao Amazon Connect, Amazon WorkSpaces, Amazon QuickSight, AWS Health Dashboard, Amazon AppStream 2.0 e Amazon Lightsail quando essas aplicações usam o AWS Sign-In para autenticar.
    • Suporte parcial a consoles: O Console Private Access está disponível em todas as Regiões comerciais da AWS, mas suporta apenas um subconjunto dos consoles de serviço. Consulte a documentação de Regiões, consoles de serviço e funcionalidades suportadas no Private Access. Para serviços não suportados, a conectividade com a internet ainda é necessária.
    • Custos: São cobrados os preços regulares de endpoint do AWS PrivateLink e processamento de dados para cada endpoint e cada Região implantada. Os três endpoints do Private Access (console, signin e console-static), mais os endpoints de serviço já utilizados, são os itens relevantes de custo.

    Conclusão

    Com o AWS Management Console Private Access, a AWS estendeu o framework de perímetro de dados ao próprio console interativo. Agora, os quatro objetivos de controle — identidade, recurso, rede de identidade e rede de recurso — que já eram aplicados ao tráfego de API também se aplicam às sessões de navegador. Para começar, consulte a documentação do AWS Management Console Private Access, as arquiteturas de referência do Console Private Access e o guia Establishing a data perimeter on AWS.

    Fonte

    Extend your data perimeter to the AWS Management Console with Private Access (https://aws.amazon.com/blogs/security/extend-your-data-perimeter-to-the-aws-management-console-with-private-access/)

  • Amazon Bedrock AgentCore Memory agora suporta controle de acesso refinado

    O que foi anunciado

    A AWS anunciou que o Amazon Bedrock AgentCore Memory passou a suportar Controle de Acesso Refinado (FGAC — Fine-Grained Access Control). Com essa novidade, equipes que desenvolvem agentes de Inteligência Artificial (IA) conseguem aplicar isolamento de memória por usuário e por tenant de forma nativa, sem precisar construir lógica de autorização customizada dentro do código da aplicação.

    Como funciona o FGAC no AgentCore Memory

    Para habilitar o FGAC, a AWS orienta que o recurso de memória seja exposto por meio do AgentCore Gateway, configurado com autenticação OAuth (JWT). A partir daí, é possível anexar políticas Cedar que restringem o acesso com base na identidade do chamador autenticado.

    Na prática, isso significa que cada usuário só consegue acessar os dados do seu próprio ator dentro da memória. Além disso, os registros de memória podem ser restritos a namespaces derivados diretamente das claims do token do usuário, e operações específicas de memória podem ser permitidas ou negadas por chamador.

    O resultado prático é significativo: o controle de acesso deixa de viver no código da aplicação e passa a ser aplicado na camada de infraestrutura, usando prova criptográfica de identidade.

    Arquitetura por trás do recurso

    O FGAC para o AgentCore Memory é construído sobre o AgentCore Memory connector, um conector de gateway gerenciado que conecta um alvo de gateway ao plano de dados do Memory. Esse conector expõe 12 operações de memória como ações Cedar, com seus atributos de requisição disponíveis para uso em condições de política.

    Essa abordagem torna a configuração de controle de acesso mais declarativa e auditável, já que as políticas Cedar descrevem explicitamente quem pode fazer o quê — sem depender de validações espalhadas pelo código da aplicação.

    Por que isso importa para times de IA

    Em cenários de agentes de IA com múltiplos usuários ou múltiplos tenants, garantir que cada entidade acesse apenas a sua própria memória é um requisito crítico de segurança e privacidade. Antes desse recurso, essa responsabilidade recaía inteiramente sobre o desenvolvedor, que precisava implementar e manter a lógica de autorização manualmente. Com o FGAC, essa camada passa a ser gerenciada pela própria infraestrutura do AgentCore.

    Como começar

    Para equipes que queiram implementar o FGAC no Amazon Bedrock AgentCore Memory, a AWS disponibiliza documentação detalhada no Guia do Desenvolvedor do AgentCore. Confira o ponto de partida recomendado: Controle de acesso refinado para Memory no Guia do Desenvolvedor do Amazon Bedrock AgentCore.

    Fonte

    Amazon Bedrock AgentCore Memory now supports fine-grained access control (https://aws.amazon.com/about-aws/whats-new/2026/08/agentcorememory-fine-grained-access-control)

  • Estendendo o Amazon Bedrock Guardrails para Interações com Ferramentas Usando o Strands Agents SDK

    O problema: guardrails de modelo não cobrem tudo

    Quem já colocou agentes de IA em produção sabe que o Amazon Bedrock Guardrails protege o que acontece na fronteira do modelo — valida o prompt antes da inferência e a resposta depois. Mas agentes fazem muito mais do que chamar modelos. Eles invocam ferramentas, buscam dados em fontes externas, se comunicam com servidores via Protocolo de Contexto de Modelo (MCP) e retornam resultados para usuários ou sistemas downstream.

    Todo esse fluxo acontece fora da fronteira do modelo, onde os guardrails de nível de modelo simplesmente não chegam. A AWS identificou quatro exposições concretas que surgem dessa lacuna:

    • Parâmetros de ferramentas passam sem verificação. O modelo decide qual ferramenta usar e quais parâmetros enviar. Se esses parâmetros contiverem Informações de Identificação Pessoal (PII) ou conteúdo que viola políticas, a ferramenta executa com esse conteúdo sem nenhuma barreira.
    • Dados externos entram sem validação. Respostas de ferramentas, saídas de servidores MCP e retornos de APIs chegam ao agente sem passar por nenhum guardrail, podendo influenciar o comportamento do modelo antes de qualquer avaliação.
    • Conteúdo enganoso afeta o raciocínio. Um agente que consome dados imprecisos de uma fonte externa pode tratá-los como autoritativos, gerando recomendações distorcidas em áreas críticas como crédito, saúde ou assessoria jurídica.
    • Sistemas multi-agente propagam dados problemáticos. Em arquiteturas com múltiplos agentes, um componente mal configurado pode passar conteúdo que viola políticas para agentes downstream — e os guardrails de cada agente individualmente não inspecionam o que trafega entre eles na camada de ferramentas.

    A solução: três pontos de validação com lifecycle hooks

    Para fechar essas lacunas, a abordagem proposta pela AWS adiciona três pontos de validação em cada fronteira de confiança onde dados entram ou saem do agente. Esses pontos são implementados com os lifecycle hooks do Strands Agents SDK, sem exigir nenhuma alteração nas ferramentas existentes ou na lógica do agente.

    Figura 1: Os três pontos de validação estendem o Amazon Bedrock Guardrails da fronteira do modelo até a fronteira das ferramentas. Imagem original — fonte: Aws

    Ponto 1 — Validação de dados de entrada (BeforeInvocationEvent)

    O primeiro ponto verifica os dados antes de chegarem ao modelo: entrada do usuário, dados vindos de outros agentes, servidores MCP e pipelines de Geração Aumentada por Recuperação (RAG). O hook BeforeInvocationEvent dispara antes da inferência ou da execução de qualquer ferramenta. Se o conteúdo violar políticas, a requisição é bloqueada e o modelo nunca vê esse conteúdo.

    Ponto 2 — Supervisão de interação com ferramentas (BeforeToolCallEvent)

    O segundo ponto age antes de o agente chamar uma ferramenta, verificando os parâmetros que seriam enviados. É exatamente a lacuna que os guardrails de nível de modelo não cobrem: o modelo já decidiu o que enviar, mas nada verificou se esse conteúdo é seguro para ser executado. O hook BeforeToolCallEvent cancela a chamada se os parâmetros forem problemáticos, antes que qualquer ação real aconteça.

    Ponto 3 — Validação de dados de saída (AfterToolCallEvent)

    O terceiro ponto valida os resultados antes de retorná-los ao usuário ou repassá-los a sistemas downstream. É especialmente importante para ferramentas que consomem conteúdo externo, como uma ferramenta de busca na web que traz páginas de sites fora do seu controle. O hook AfterToolCallEvent valida o retorno da ferramenta e o substitui por uma mensagem de bloqueio se o conteúdo violar políticas.

    A intensidade de validação de cada ponto pode ser ajustada de forma independente. No Ponto 1, faz sentido usar um guardrail completo com detecção de PII, filtragem de conteúdo e aplicação de tópicos. O Ponto 2 pode ser mais leve — um guardrail separado com regras específicas para a ferramenta em questão, ou verificações locais como validação de expressão regular ou de schema. O Ponto 3 deve focar na detecção de conteúdo indesejado nas saídas que trazem dados externos. Combinar verificações determinísticas rápidas (regex, validação de schema, listas de permissão) com avaliações baseadas em IA mantém a latência baixa.

    Implementação passo a passo

    A implementação usa o boto3, o SDK da AWS para Python, para chamar a API ApplyGuardrail. O Strands Agents SDK expõe um evento de lifecycle por ponto de validação.

    Pré-requisitos

    Antes de implementar a abordagem com múltiplos pontos de validação, você precisará de:

    • Uma conta AWS com acesso ao Amazon Bedrock
    • Amazon Bedrock Guardrails configurado
    • Python 3.11 ou superior instalado
    • Strands Agents SDK instalado: pip install strands-agents
    • Credenciais AWS configuradas com permissões para bedrock:ApplyGuardrail e bedrock:InvokeModel
    • O ID e a versão do seu guardrail, obtidos no console do Amazon Bedrock (navegue até Guardrails, selecione seu guardrail e copie o ID)

    Este guia pressupõe que você já tem um agente Strands funcionando com acesso mínimo privilegiado às ferramentas, prompts de sistema com escopo definido e lógica de negócios validada. Se estiver começando do zero, a AWS recomenda consultar o artigo Strands Agents SDK: A technical deep dive into agent architectures and observability para um passo a passo completo de construção e implantação com o Amazon Bedrock Agent Core.

    Criando o hook de validação de guardrail

    A classe GuardrailHook é um HookProvider do Strands. Ela registra três callbacks, um para cada evento de lifecycle. Quando o Strands dispara um evento, o callback correspondente executa: validate_inbound verifica mensagens do usuário, validate_input verifica parâmetros de ferramentas antes da execução e validate_output verifica os resultados das ferramentas. Os três usam o método compartilhado _check, que chama a API ApplyGuardrail do Amazon Bedrock.

    Crie um arquivo guardrail_hook.py e adicione a implementação abaixo. Use o parâmetro opcional tool_names para restringir o hook a ferramentas específicas, ou passe None para aplicar em todas:

    import boto3
    from strands.hooks import HookProvider, HookRegistry
    from strands.hooks.events import (
        BeforeInvocationEvent,
        BeforeToolCallEvent,
        AfterToolCallEvent,
    )
    
    class GuardrailHook(HookProvider):
        def __init__(self, guardrail_id, guardrail_version, region_name, tool_names=None):
            self.client = boto3.client("bedrock-runtime", region_name=region_name)
            self.guardrail_id = guardrail_id
            self.guardrail_version = guardrail_version
            self.tool_names = tool_names  # None = apply to all tools
    
        def register_hooks(self, registry: HookRegistry, **kwargs):
            registry.add_callback(BeforeInvocationEvent, self.validate_inbound)
            registry.add_callback(BeforeToolCallEvent, self.validate_input)
            registry.add_callback(AfterToolCallEvent, self.validate_output)
    
        def _check(self, content, source="INPUT"):
            """Call Bedrock ApplyGuardrail. Returns True if content is safe."""
            response = self.client.apply_guardrail(
                guardrailIdentifier=self.guardrail_id,
                guardrailVersion=self.guardrail_version,
                source=source,  # "INPUT" applies input policies; "OUTPUT" applies output policies
                content=[{"text": {"text": content}}],
            )
            return response["action"] != "GUARDRAIL_INTERVENED"
    
        # Checkpoint 1 — BeforeInvocationEvent
        # Validates user input before model inference or tool execution occurs.
        # The model does not see blocked content.
        async def validate_inbound(self, event: BeforeInvocationEvent):
            for msg in reversed(event.messages):
                if msg.get("role") == "user":
                    for block in msg.get("content", []):
                        text = block.get("text", "")
                        if text and not self._check(text):
                            event.messages.clear()
                            event.messages.append({
                                "role": "user",
                                "content": [{"text": "Request blocked by safety guardrail."}],
                            })
                            return
                    break
    
        # Checkpoint 2 — BeforeToolCallEvent
        # Validates tool input parameters before the tool executes.
        # Skips tools not in tool_names (if a filter is set).
        async def validate_input(self, event: BeforeToolCallEvent):
            if self.tool_names and event.tool_use.get("name") not in self.tool_names:
                return
            tool_input = event.tool_use.get("input", {})
            for param_value in tool_input.values():
                if isinstance(param_value, str) and not self._check(param_value):
                    event.cancel_tool = "This request was blocked by a safety guardrail."
                    return
    
        # Checkpoint 3 — AfterToolCallEvent
        # Validates tool output before it reaches the agent.
        # Skips tools not in tool_names (if a filter is set).
        async def validate_output(self, event: AfterToolCallEvent):
            if self.tool_names and event.tool_use.get("name") not in self.tool_names:
                return
            content_parts = [
                block["text"]
                for block in event.result.get("content", [])
                if "text" in block
            ]
            content = "\n".join(content_parts)
            if content and not self._check(content, source="OUTPUT"):
                event.result = {
                    "toolUseId": event.result["toolUseId"],
                    "status": "error",
                    "content": [{"text": "Content blocked by safety guardrail."}],
                }

    Definindo ferramentas

    O Strands descobre ferramentas pelo decorator @tool, que transforma uma função Python comum em uma ferramenta que o modelo pode chamar, usando a docstring e as type hints como contrato da ferramenta. Abaixo estão dois exemplos simples usados nas seções de registro:

    from strands import tool
    
    @tool
    def web_search(query: str) -> str:
        """Search the web and return a result snippet."""
        # Replace with your actual search implementation
        return f"Search results for: {query}"
    
    @tool
    def get_customer_data(customer_id: str) -> str:
        """Retrieve customer record by ID."""
        # Replace with your actual data lookup implementation
        return f"Customer record for: {customer_id}"

    Registrando o hook

    O Strands ativa hooks pelo parâmetro hooks no construtor do Agent. Após o registro, os callbacks do hook executam automaticamente em cada evento de lifecycle correspondente, sem nenhuma alteração nas ferramentas ou na lógica do agente.

    Para um único guardrail aplicado a todas as ferramentas, crie uma instância do hook e passe-a ao agente:

    from strands import Agent
    from strands.models import BedrockModel
    from guardrail_hook import GuardrailHook
    from tools import web_search, get_customer_data  # Example tools - replace with your tools
    
    # Example model and region selection
    model = BedrockModel(
        model_id="us.anthropic.claude-sonnet-4-5",
        region_name="us-east-1",
    )
    
    guardrail_hook = GuardrailHook(
        guardrail_id="your-guardrail-id",  # Copy it from the Amazon Bedrock console > Guardrails
        guardrail_version="1",  # Use "DRAFT" for testing
        region_name="us-east-1",  # Region where the guardrails are defined
    )
    
    agent = Agent(
        model=model,
        tools=[web_search, get_customer_data],  # Example tools
        system_prompt="You are a helpful assistant.",  # Example system prompt
        hooks=[guardrail_hook],  # Applied to all tool calls
    )

    Usando guardrails diferentes por ferramenta

    Ferramentas diferentes carregam riscos diferentes. Uma ferramenta de busca na web traz conteúdo externo de sites não confiáveis e precisa de filtragem de saída rigorosa. Uma ferramenta de dados de clientes retorna registros internos e pode precisar de detecção de PII configurada de forma diferente.

    O parâmetro tool_names restringe um hook a ferramentas específicas. O Strands ainda executa todos os hooks registrados em cada evento, mas os hooks ignoram a chamada quando o nome da ferramenta não corresponde. Registre um hook por guardrail:

    from strands import Agent
    from strands.models import BedrockModel
    from guardrail_hook import GuardrailHook
    from tools import web_search, get_customer_data  # Example tools - replace with your tools
    
    # Example model and region selection
    model = BedrockModel(
        model_id="us.anthropic.claude-sonnet-4-5",
        region_name="us-east-1",
    )
    
    # Strict content filtering and PII detection for web search results
    web_search_hook = GuardrailHook(
        guardrail_id="gr-websearch-id",  # Guardrail ID with content filtering + PII detection
        guardrail_version="1",  # Or set to DRAFT
        region_name="us-east-1",  # Change to your region
        tool_names={"web_search"},  # Only applies to the web_search tool
    )
    
    # PII detection for customer data — prevents sensitive records from leaking into tool parameters
    customer_data_hook = GuardrailHook(
        guardrail_id="gr-customerdata-id",  # Guardrail ID with PII detection
        guardrail_version="1",  # Or set to DRAFT
        region_name="us-east-1",  # Change to your region
        tool_names={"get_customer_data"},  # Only applies to the get_customer_data tool
    )
    
    agent = Agent(
        model=model,
        tools=[web_search, get_customer_data],  # Example tools
        system_prompt="You are a helpful assistant.",  # Example system prompt
        hooks=[web_search_hook, customer_data_hook],  # Each hook runs only for its assigned tools
    )

    Cada guardrail é configurado de forma independente no console do Amazon Bedrock, permitindo ajustar a rigidez da validação ao nível de risco de cada ferramenta, em vez de aplicar uma política única para todo o agente.

    Testando a implementação

    Para validar o funcionamento, crie uma pasta de projeto com os seguintes arquivos:

    • guardrail_hook.py — a classe GuardrailHook
    • tools.py — as definições das ferramentas web_search e get_customer_data
    • agent.py — a configuração do agente da seção de registro do hook

    Em agent.py, adicione um prompt de teste ao final:

    # Send a test prompt
    response = agent("Search the web for the latest news on AI security.")
    print(response)

    Atualize os IDs de guardrail, a região AWS e o ID do modelo em agent.py para corresponder à sua configuração. Execute o agente a partir da pasta do projeto:

    python agent.py

    O hook de guardrail executa em cada ponto de validação. Se o prompt ou qualquer saída de ferramenta for sinalizado, você verá a mensagem de bloqueio na resposta em vez do resultado da ferramenta.

    Reutilizando o hook em toda a organização

    A classe GuardrailHook é um HookProvider independente. Construída uma vez, ela pode ser anexada a agentes Strands passando-a no parâmetro hooks. O mesmo pacote de hook pode ser publicado como uma biblioteca interna e consumido por:

    É possível trocar configurações de guardrail ou adicionar verificações como regex ou validação de schema sem tocar no código do agente ou das ferramentas.

    Conclusão

    O Amazon Bedrock Guardrails protege a fronteira do modelo, mas agentes também chamam ferramentas, consomem dados externos e retornam resultados que nunca passam pelas verificações de nível de modelo. Os três pontos de validação apresentados neste guia fecham essa lacuna usando os lifecycle hooks do Strands Agents SDK: BeforeInvocationEvent valida a entrada do usuário, BeforeToolCallEvent valida os parâmetros das ferramentas e AfterToolCallEvent valida a saída das ferramentas.

    A mesma classe GuardrailHook suporta tanto um guardrail compartilhado quanto guardrails diferentes com escopo por ferramenta, e pode ser implantada sem alterações desde o teste local até o Amazon Bedrock Agent Core Runtime.

    Para se aprofundar no tema, a AWS recomenda consultar também o OWASP Top 10 para Aplicações Agênticas, que traz as principais vulnerabilidades a considerar nesse tipo de arquitetura.

    Fonte

    Extend Amazon Bedrock Guardrails to Tool Interactions Using the Strands Agents SDK (https://aws.amazon.com/blogs/security/extend-amazon-bedrock-guardrails-to-tool-interactions-using-the-strands-agents-sdk/)

  • Amazon RDS para PostgreSQL passa a suportar as versões menores 18.6, 17.11, 16.15, 15.19 e 14.24

    Novas versões menores disponíveis no Amazon RDS para PostgreSQL

    A AWS anunciou que o Amazon Serviço de Banco de Dados Relacional (RDS) para PostgreSQL agora oferece suporte às versões menores mais recentes do PostgreSQL: 18.6, 17.11, 16.15, 15.19 e 14.24. A recomendação oficial é que todos os usuários realizem o upgrade para essas versões o quanto antes.

    Por que atualizar?

    O principal motivo para realizar o upgrade é a correção de Vulnerabilidades e Exposições Comuns (CVEs) presentes nas versões anteriores do PostgreSQL. Além da segurança, as novas versões menores incorporam correções de bugs e melhorias desenvolvidas pela comunidade PostgreSQL, tornando os bancos de dados mais estáveis e confiáveis.

    Como realizar o upgrade

    A AWS oferece algumas formas práticas de executar a atualização com o mínimo de impacto nas operações:

    • Janelas de manutenção programadas: é possível configurar upgrades automáticos de versões menores para que sejam aplicados durante as janelas de manutenção agendadas, sem necessidade de intervenção manual.
    • AWS Organizations com Política de Rollout de Upgrade: para equipes que gerenciam múltiplos ambientes em escala, esse recurso permite orquestrar os upgrades em fases — validando primeiro nos ambientes de menor prioridade antes de aplicar nas cargas de trabalho mais críticas.
    • Implantações Blue/Green do Amazon RDS: para quem precisa minimizar ao máximo o tempo de inatividade durante o processo de atualização, as implantações Blue/Green são uma alternativa eficiente.

    Para mais detalhes sobre o processo de atualização, a AWS disponibiliza a documentação Atualizando a engine de banco de dados RDS para PostgreSQL.

    Sobre o Amazon RDS para PostgreSQL

    O Amazon RDS para PostgreSQL é um serviço gerenciado que simplifica a configuração, operação e escalabilidade de implantações PostgreSQL na nuvem. Para criar ou atualizar um banco de dados, é possível utilizar o Console de Gerenciamento do Amazon RDS ou a Interface de Linha de Comando (CLI) da AWS. Informações sobre preços e disponibilidade por região estão disponíveis na página de Preços do Amazon RDS para PostgreSQL.

    Fonte

    Amazon RDS for PostgreSQL supports minor versions 18.6, 17.11, 16.15, 15.19, and 14.24 (https://aws.amazon.com/about-aws/whats-new/2026/08/amazon-rds-postgresql-18-6-17-11-16-15-15-19-14-24/)

  • AWS Lambda MicroVMs passa a suportar AWS PrivateLink

    Conectividade privada chega ao Lambda MicroVMs

    A AWS anunciou que o Lambda MicroVMs agora conta com suporte ao AWS PrivateLink, possibilitando conectividade privada diretamente a partir de recursos de uma Nuvem Privada Virtual (VPC — Virtual Private Cloud) sem que o tráfego precise passar pela internet pública.

    A novidade é especialmente relevante para equipes que trabalham com cargas de trabalho reguladas — como as dos setores financeiro, de saúde e governamental —, que precisam cumprir requisitos rigorosos de isolamento de rede ao construir soluções com o Lambda MicroVMs.

    O que são os Endpoints de VPC do PrivateLink?

    Os Endpoints de VPC do PrivateLink (PrivateLink VPC Endpoints) entregam conectividade privada entre uma VPC e os serviços da AWS, garantindo que o tráfego não trafegue pela internet pública durante a comunicação com esses serviços. Com este lançamento, essa capacidade é estendida ao Lambda MicroVMs.

    O que muda na prática para desenvolvedores e times de TI

    Desenvolvedores e equipes de TI que precisam de conectividade privada com o Lambda MicroVMs agora podem criar Endpoints de VPC do PrivateLink dentro de sua VPC para:

    • Chamar as APIs do MicroVM — por exemplo, para criar imagens de MicroVM ou inicializar MicroVMs;
    • Conectar-se ao endpoint HTTP de cada MicroVM individualmente.

    Os Endpoints de VPC do PrivateLink para o Lambda MicroVMs podem ser criados por meio do Console de Gerenciamento da AWS (AWS Management Console), da Interface de Linha de Comando da AWS (AWS CLI), do AWS CloudFormation ou dos SDKs da AWS.

    Disponibilidade e recursos adicionais

    O recurso está disponível em todas as regiões onde o Lambda MicroVMs já é oferecido. Para verificar a disponibilidade mais atualizada por região, a AWS disponibiliza a página de Capacidades da AWS por Região.

    Para aprofundar o conhecimento sobre o uso do PrivateLink com o Lambda MicroVMs, a AWS disponibiliza um guia do desenvolvedor dedicado ao tema. Informações sobre preços podem ser consultadas na página de preços do AWS PrivateLink. Para entender melhor como configurar conectividade privada para serviços da AWS de forma geral, o guia do desenvolvedor do AWS PrivateLink é o ponto de partida recomendado.

    Fonte

    AWS Lambda MicroVMs now supports AWS PrivateLink (https://aws.amazon.com/about-aws/whats-new/2026/08/lambda-microvms-supports-privatelink)

  • Acelere ambientes ISM e avaliações IRAP com o Landing Zone Accelerator na AWS

    O que foi anunciado

    A AWS anunciou a disponibilidade de um novo relatório de avaliação independente no AWS Artifact, que analisa como o Landing Zone Accelerator na AWS (LZA) pode implantar automaticamente ambientes multi-conta com cobertura dos controles de segurança definidos pelo Manual de Segurança da Informação do Governo Australiano — o Manual de Segurança da Informação do Governo Australiano (ISM). A análise foi conduzida de forma independente pelo parceiro AWS gwi.digital, uma consultoria especializada em cibersegurança e governança, risco e conformidade (GRC), com ampla experiência em avaliações IRAP e no framework ISM.

    Além do relatório em si, a AWS apresenta informações sobre a aplicabilidade do ISM ao LZA e um novo mecanismo de teste para medir desvios de configuração — recursos que, em conjunto, oferecem às organizações australianas uma base documentada e validada para acelerar a preparação para avaliações IRAP (Programa de Avaliadores Registrados de Segurança da Informação).

    Contexto: por que isso importa para o setor público australiano

    Organizações australianas do setor público, defesa e infraestrutura crítica precisam construir ambientes de nuvem que atendam aos requisitos do ISM. Esse manual define 1.081 requisitos de controle de segurança distribuídos em 22 capítulos de diretrizes. Demonstrar conformidade é parte central para obter um resultado positivo em uma avaliação IRAP — mas essas avaliações normalmente exigem meses de preparação, coleta de evidências e testes.

    Em outubro de 2025, a AWS introduziu a Configuração Universal do LZA e o LZA Compliance Workbook. O LZA provisiona uma arquitetura de segurança multi-conta que automatiza a implantação de quase 200 controles de segurança baseados nos pilares do AWS Well-Architected e nas melhores práticas de segurança da AWS. O LZA Compliance Workbook, disponível no AWS Artifact, documenta como a Configuração Universal (UC) se mapeia para requisitos técnicos de segurança de 17 frameworks globais de conformidade, com mais sendo adicionados.

    O LZA é uma solução adequada para clientes com obrigações de segurança e conformidade — tanto existentes quanto previstas — porque os controles que ele implanta são aplicados automaticamente a novas contas à medida que os ambientes crescem.

    O que o relatório cobre

    Para avaliar como o LZA pode ajudar clientes na Austrália, a AWS trabalhou em conjunto com o parceiro gwi.digital para executar o LZA da mesma forma que um cliente faria. A equipe conduziu uma análise e avaliação independente da Configuração Universal do LZA contra os 1.081 controles do ISM.

    A avaliação foi realizada em um ambiente AWS totalmente novo (greenfield), hospedado na região AWS ap-southeast-2 (Sydney), posicionado dentro da Fase 2 do Framework de Avaliação e Autorização de Segurança em Nuvem da ASD (Diretoria Australiana de Sinais). O foco foi em consumidores de nuvem que constroem sobre serviços AWS já autorizados. A iniciativa se apoia nas fundações IRAP existentes da AWS: os serviços subjacentes da AWS foram avaliados de forma independente no nível PROTECTED pela CyberCX.

    É importante destacar: o relatório não constitui uma autorização, certificação ou credenciamento IRAP oficial. Ele fornece uma avaliação profissional de evidências com base no que o LZA entrega por padrão — e no que ele não entrega —, permitindo que as organizações tomem decisões informadas.

    O que a avaliação encontrou

    Dos 1.081 controles do ISM, 256 estão dentro do escopo endereçável pelo LZA — ou seja, são os controles de infraestrutura técnica que uma solução como o LZA pode efetivamente tratar. Desses 256, o LZA alcança cobertura Total ou Parcial em 234, o que representa 91% dos controles aplicáveis.

    Os 825 controles restantes estão fora do escopo do LZA: segurança física, pessoal, governança organizacional e exclusões por nível de classificação.

    Uma contribuição relevante da avaliação foi a análise do modelo de responsabilidade compartilhada que vai além da visão binária tradicional entre AWS e cliente. O relatório considera uma visão em três camadas — AWS (fornecido), LZA (habilitado) e Cliente (responsabilidade) — e categoriza os 825 controles fora do escopo em subcategorias, permitindo que as organizações identifiquem rapidamente quais controles ainda exigem atenção delas, em comparação com os que já estão cobertos no nível de infraestrutura.

    Validação contínua com o CATS

    Confirmar que os controles estão implementados e operando de forma eficaz em todo o ambiente é uma tarefa complexa e frequentemente sem cobertura completa. Para simplificar esse processo, a AWS desenvolveu o CATS (Suíte de Testes de Aceitação de Controles).

    O CATS é um mecanismo automatizado de validação de conformidade que executa testes específicos contra a linha de base de configuração de segurança implantada pela Configuração Universal do LZA. Para a avaliação do ISM, o CATS executou mais de 3.600 testes individuais em seis contas AWS, avaliando estrutura de contas, identidade e acesso, configuração de rede, logging, criptografia e backup.

    Para clientes australianos, o CATS oferece os seguintes benefícios:

    • Geração automatizada de evidências: resultados legíveis por máquina podem substituir semanas de coleta manual de evidências
    • Relatórios enriquecidos com ISM: a gwi.digital desenvolveu um script de conversão que mapeia a saída do CATS para referências de controle do ISM, permitindo que auditores interpretem os resultados sob a perspectiva do ISM
    • Exportação em OSCAL: resultados no formato da Linguagem de Avaliação de Controles de Segurança Aberta (OSCAL) para interoperabilidade com ferramentas de avaliação
    • Detecção contínua de desvios: a execução repetível identifica quando as configurações se afastam da linha de base validada entre os ciclos de avaliação

    Atenção: a disponibilidade do CATS é limitada e atualmente acessível apenas por meio do AWS Professional Services como solução em beta privado, podendo estar sujeita a alterações. Disponibilidade, funcionalidades e preços podem mudar sem aviso prévio.

    Ajustes de configuração otimizados para o ISM

    Durante a avaliação, a gwi.digital identificou ajustes de configuração que elevam classificações específicas de controles de Parcial para Total, com esforço mínimo. Como exemplo, aumentar o comprimento mínimo de senha padrão de 14 para 15 caracteres, ou ajustar a retenção de logs para se alinhar aos padrões australianos de descarte de registros federais. Essas recomendações foram comunicadas à equipe de Configuração Universal do LZA para inclusão em uma futura seção de orientações específicas para o ISM na documentação do GitHub do LZA.

    Como começar

    Para quem deseja explorar esses recursos, a AWS recomenda os seguintes passos:

    Em caso de dúvidas, é possível entrar em contato com um especialista da gwi.digital, com um membro da equipe LZA da AWS ou com o representante de conta AWS.

    Conclusão

    A combinação dos mapeamentos ISM no LZA Compliance Workbook, do relatório de análise da gwi.digital e das evidências geradas pelo CATS oferece às organizações australianas uma vantagem significativa na preparação para avaliações IRAP. Entre os principais ganhos práticos estão:

    • Semanas economizadas no escopo: a aplicabilidade pré-determinada dos controles reduz significativamente o esforço inicial de definição de escopo
    • Documentação pronta: os statements de implementação e o alinhamento de requisitos de controle reduzem a carga de documentação
    • Garantia independente: um relatório de terceiros que clientes e seus avaliadores podem referenciar diretamente
    • Evidência contínua: o CATS gera evidências de segurança repetíveis entre os ciclos de avaliação, substituindo auditorias manuais periódicas por garantia contínua

    Fonte

    Fast Track ISM-ready cloud environments and IRAP Assessments with Landing Zone Accelerator on AWS (https://aws.amazon.com/blogs/security/fast-track-ism-ready-cloud-environments-and-irap-assessments-with-landing-zone-accelerator-on-aws/)

  • Amazon EKS agora suporta múltiplos provedores de identidade OIDC externos por cluster

    O que mudou no Amazon EKS

    A AWS anunciou uma atualização importante no Amazon Elastic Kubernetes Service (Amazon EKS): agora é possível associar múltiplos provedores de identidade externos baseados em OpenID Connect (OIDC) a um único cluster. Com essa novidade, cada cluster pode ter até 10 provedores OIDC configurados simultaneamente, ampliando consideravelmente a flexibilidade na autenticação de usuários e cargas de trabalho.

    Por que isso importa na prática

    Muitas organizações trabalham com diferentes grupos de usuários — funcionários internos, prestadores de serviço, sistemas de Integração Contínua e Entrega Contínua (CI/CD), entre outros. Cada um desses grupos costuma ter seu próprio provedor de identidade, e até então o EKS exigia que tudo fosse consolidado em um único provedor ou que se usasse um broker de identidade intermediário para contornar essa limitação.

    Com a atualização, cada grupo pode se autenticar diretamente pelo seu próprio provedor, sem a necessidade de centralização forçada ou de soluções de contorno. Cada provedor é configurado e gerenciado de forma independente, com seu próprio mapeamento de identidade.

    Compatibilidade com a autenticação IAM existente

    Um ponto relevante destacado pela AWS é que a autenticação via IAM (Gerenciamento de Identidade e Acesso) continua funcionando normalmente em paralelo com todos os provedores OIDC configurados. Ou seja, não é necessário abrir mão da configuração atual para aproveitar a nova capacidade.

    Como configurar

    A forma de adicionar provedores segue o mesmo processo já conhecido: via AWS Management Console ou por meio da API AssociateIdentityProviderConfig, acessível pelo AWS CLI e pelos AWS SDKs. Não há mudança no fluxo de configuração — apenas a possibilidade de repetir o processo para cada novo provedor que precise ser associado ao cluster.

    Disponibilidade e custo

    A funcionalidade está disponível em todas as regiões da AWS onde o Amazon EKS é oferecido e não tem custo adicional.

    Para se aprofundar na configuração, a documentação oficial da AWS traz um guia detalhado: Conceder acesso a usuários no Kubernetes com um provedor OIDC externo, disponível no Amazon EKS User Guide.

    Fonte

    Amazon EKS now supports multiple external OIDC identity providers per cluster (https://aws.amazon.com/about-aws/whats-new/2026/08/amazon-eks-multiple-oidc-providers)