Usando filas de mensagens mortas para capturar erros de eventos criptografados

Se você configurar a chave gerenciada pelo cliente criptografia em um barramento de eventos, recomendamos que você especifique uma fila de mensagens mortas (DLQ) para esse barramento de eventos. EventBridge envia eventos personalizados e de parceiros para essa DLQ se ela encontrar um erro não recuperável ao processar o evento no barramento de eventos. Um erro não recuperável é aquele em que a ação do usuário é necessária para resolver o problema subjacente, como o especificado chave gerenciada pelo cliente estar desativado ou ausente.

• Se ocorrer um erro de criptografia ou descriptografia não recuperável durante EventBridge o processamento do evento no barramento de eventos, o evento será enviado à DLQ para o barramento de eventos, se houver um especificado.

• Se ocorrer um erro de criptografia ou descriptografia não recuperável durante EventBridge a tentativa de enviar o evento para um destino, o evento será enviado ao DLQ do destino, se houver um especificado.

Para obter mais informações, incluindo considerações sobre o uso de DLQs e instruções sobre como definir permissões, consulte. Usando filas de cartas mortas para processar eventos não entregues

Descriptografando eventos em filas de mensagens mortas EventBridge

Depois de resolver o problema subjacente que está causando um erro não recuperável, você pode processar os eventos enviados para o barramento de eventos ou para as DLQs de destino. Para eventos criptografados, você deve primeiro descriptografar o evento para processá-lo.

O exemplo a seguir demonstra como descriptografar um evento que EventBridge foi entregue a um barramento de eventos ou DLQ de destino.

// You will receive an encrypted event in the following json format.
        // ```
        //   {
        //     "version": "0", 
        //     "id": "053afa53-cdd7-285b-e754-b0dfd0ac0bfb",  // New event id not the same as the original one
        //     "account": "123456789012",  
        //     "time": "2020-02-10T10:22:00Z",  
        //     "resources": [ ],
        //     "region": "us-east-1",
        //     "source": "aws.events",
        //     "detail-type": "Encrypted Events",
        //     "detail": { 
        //       "event-bus-arn": "arn:aws:events:region:account:event-bus/bus-name", 
        //       "rule-arn": "arn:aws:events:region:account:event-bus/bus-name/rule-name", 
        //       "kms-key-arn": "arn:aws:kms:region:account:key/key-arn", 
        //       "encrypted-payload": "AgR4qiru/XNwTUyCgRHqP7rbbHn/xpmVeVeRIAd12TDYYVwAawABABRhd3M6ZXZlbnRzOmV2ZW50LWJ1cwB
        //                             RYXJuOmF3czpldmVudHM6dXMtZWFzdC0xOjE0NjY4NjkwNDY3MzpldmVudC1idXMvY21rbXMtZ2EtY3Jvc3
        //                             MtYWNjb3VudC1zb3VyY2UtYnVzAAEAB2F3cy1rbXMAS2Fybjphd3M6a21zOnVzLWVhc3QtMToxNDY2ODY5"
        //     }
        //   }
        // ```
 
        // Construct an AwsCrypto object with the encryption algorithm `ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY` which 
        // is used by EventBridge for encryption operation. This object is an entry point for decryption operation. 
        // It can later use decryptData(MasterKeyProvider, byte[]) method to decrypt data.
        final AwsCrypto crypto = AwsCrypto.builder()
                .withEncryptionAlgorithm(CryptoAlgorithm.ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY)
                .build();
 
        // Construct AWS KMS master key provider with AWS KMS Client Supplier and AWS KMS Key ARN. The KMS Client Supplier can 
        // implement a RegionalClientSupplier interface. The AWS KMS Key ARN can be fetched from kms-key-arn property in 
        // encrypted event json detail.
        final KmsMasterKeyProvider kmsMasterKeyProvider = KmsMasterKeyProvider.builder()
                .customRegionalClientSupplier(...)
                .buildStrict(KMS_KEY_ARN);
 
        // The string of encrypted-payload is base64 encoded. Decode it into byte array, so it can be furthur 
        // decrypted. The encrypted payload can be fetched from encrypted-payload field in encrypted event json detail.
        byte[] encryptedByteArray = Base64.getDecoder().decode(ENCRYPTED_PAYLOAD);
 
        // The decryption operation. It retrieves the encryption context and encrypted data key from the cipher 
        // text headers, which is parsed from byte array encrypted data. Then it decrypts the data key, and 
        // uses it to finally decrypt event payload. This encryption/decryption strategy is called envelope 
        // encryption, https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#enveloping
        final CryptoResult<byte[], KmsMasterKey> decryptResult = crypto.decryptData(kmsMasterKeyProvider, encryptedByteArray);
 
        final byte[] decryptedByteArray = decryptResult.getResult();
    
        // Decode the event json plaintext from byte array into string with UTF_8 standard.
        String eventJson = new String(decryptedByteArray, StandardCharsets.UTF_8);