Chiffrement AWS Lambda données d'exécution durables

Grâce à des fonctions AWS Lambda durables, vous pouvez créer des applications résilientes en plusieurs étapes qui s'exécutent jusqu'à un an, en utilisant des points de contrôle pour récupérer chaque exécution après des échecs en rejouant le travail terminé.

Lambda chiffre toujours les données d'exécution durables au repos. Vous pouvez également configurer votre propre clé gérée par le AWS KMS client sur la fonction pour le contrôle de la rotation, la visibilité des audits ou la conformité. Avec une clé gérée par le client, seuls les mandants que vous autorisez peuvent lire les données d'exécution.

Comment fonctionne le chiffrement

Une exécution Lambda durable utilise la même clé KMS avec laquelle elle a commencé pendant toute sa durée de vie. La modification ou la suppression de la touche de la fonction n'affecte que les exécutions qui démarrent après la modification. Découvrez Lorsque la clé gérée par le client n'est pas disponible comment se comporte une exécution durable lorsque sa clé n'est pas disponible.

Les clés gérées par le client entraînent des AWS KMS frais standard. Pour plus d’informations sur la tarification, consultez Tarification AWS Key Management Service.

Qu'est-ce qui est crypté

Lorsque vous configurez une clé gérée par le client sur une fonction durable, Lambda utilise cette clé pour chiffrer les données d'exécution durables suivantes au repos :

Configurer le chiffrement des clés gérées par le client

La configuration du chiffrement par clé gérée par le client pour une fonction durable est un processus en trois étapes. Effectuez les étapes suivantes dans l'ordre.

Création d’une clé gérée par le client

Les fonctions durables prennent en charge les clés KMS de chiffrement symétrique dans la même AWS région que la fonction. Cross-Region les clés ne sont pas prises en charge. Pour créer une clé symétrique gérée par le client, suivez les étapes de création de clés KMS à chiffrement symétrique décrites dans le Guide du AWS Key Management Service développeur.

Permissions

Vous accordez AWS KMS des autorisations par le biais de la politique de clé de la clé KMS.

La configuration d'une clé gérée par le client nécessite AWS KMS des autorisations sur le principal qui crée ou met à jour la fonction. L'appel d'une fonction durable ne nécessite aucune AWS KMS autorisation de la part de l'appelant ; Lambda effectue le chiffrement avec son principal de service.

Stratégie de clé

Les stratégies de clé contrôlent l’accès à votre clé gérée par le client. Chaque clé gérée par le client doit avoir exactement une politique clé. Dans une politique de clé, Resource: "*" fait référence uniquement à la clé KMS à laquelle la politique est associée, et non à toutes les clés KMS de votre compte.

La politique clé d'une fonction durable n'accorde à chaque responsable que les AWS KMS actions dont il a besoin, en fonction de l'ARN du service et de la fonction. Les sections suivantes décrivent les déclarations, les conditions et fournissent un exemple complet.

Déclarations de politique requises

La politique accorde les fonctionnalités suivantes :

Il est recommandé d'utiliser des principes distincts pour le rôle d'exécution, l'auteur de la fonction et l'opérateur d'exécution durable afin que chaque identité ne dispose que des fonctionnalités dont elle a besoin.

Conditions politiques recommandées

La politique utilise les conditions suivantes pour limiter l'accès :

L'exemple suivant combine les déclarations et les conditions ci-dessus.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "Enable IAM User Permissions",
            "Effect": "Allow",
            "Principal": { "AWS": "arn:aws:iam::111122223333:root" },
            "Action": "kms:*",
            "Resource": "*"
        },
        {
            "Sid": "Allow Lambda to use this key for durable functions",
            "Effect": "Allow",
            "Principal": { "Service": "lambda.amazonaws.com" },
            "Action": [ "kms:GenerateDataKey", "kms:Decrypt" ],
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "aws:SourceAccount": "111122223333",
                    "aws:SourceArn": "arn:aws:lambda:us-east-1:111122223333:function:myDurableFunction",
                    "kms:EncryptionContext:aws:lambda:FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:myDurableFunction"
                }
            }
        },
        {
            "Sid": "Allow the function execution role to decrypt durable execution data",
            "Effect": "Allow",
            "Principal": { "AWS": "arn:aws:iam::111122223333:role/myDurableFunctionRole" },
            "Action": "kms:Decrypt",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "kms:ViaService": "lambda.us-east-1.amazonaws.com",
                    "kms:EncryptionContext:aws:lambda:FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:myDurableFunction"
                }
            }
        },
        {
            "Sid": "Allow the function author to describe this key",
            "Effect": "Allow",
            "Principal": { "AWS": "arn:aws:iam::111122223333:role/FunctionAuthor" },
            "Action": "kms:DescribeKey",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "kms:ViaService": "lambda.us-east-1.amazonaws.com"
                }
            }
        },
        {
            "Sid": "Allow the function author to validate this key for a specific function",
            "Effect": "Allow",
            "Principal": { "AWS": "arn:aws:iam::111122223333:role/FunctionAuthor" },
            "Action": [ "kms:GenerateDataKey", "kms:Decrypt" ],
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "kms:ViaService": "lambda.us-east-1.amazonaws.com",
                    "kms:EncryptionContext:aws:lambda:FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:myDurableFunction"
                }
            }
        },
        {
            "Sid": "Allow durable execution operators",
            "Effect": "Allow",
            "Principal": { "AWS": "arn:aws:iam::111122223333:role/DurableExecutionOperator" },
            "Action": "kms:Decrypt",
            "Resource": "*",
            "Condition": {
                "StringEquals": {
                    "kms:ViaService": "lambda.us-east-1.amazonaws.com",
                    "kms:EncryptionContext:aws:lambda:FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:myDurableFunction"
                }
            }
        }
    ]
}

Pour plus d'informations sur les politiques AWS KMS clés, consultez Comment modifier une stratégie clé dans le Guide du AWS Key Management Service développeur.

Configurer une clé gérée par le client sur une fonction durable

Vous configurez la clé gérée par le client pour obtenir des données d'exécution durables via le KMSKeyArn champ de l'DurableConfigobjet. Configurez-le lorsque vous créez la fonction avec CreateFunction  ; mettez-le à jour sur une fonction durable existante avec UpdateFunctionConfiguration.

Lecture de données d'exécution durables

Deux API de lecture renvoient des données d'exécution durables :

Les deux API acceptent un paramètre de IncludeExecutionData demande. Lorsque IncludeExecutionData c'est le castrue, Lambda utilise les informations d'identification de l'appelant pour appeler la clé gérée par kms:Decrypt le client. Lambda renvoie ensuite les données d'exécution déchiffrées dans la réponse. L'identité de l'appelant doit figurer kms:Decrypt sur la clé gérée par le client.

Lorsque IncludeExecutionData c'est false le cas, Lambda n'appelle AWS KMS ni ne déchiffre les données d'exécution et la réponse est définie sur. ExecutionDataIncluded false La réponse inclut toujoursDurableConfig, ce qui fait écho à l'ARN clé géré par le client que l'exécution a utilisé. IncludeExecutionDataest défini par défautfalse, de sorte que les appelants qui n'ont besoin que de métadonnées n'ont pas besoin d' AWS KMS autorisations.

Exemple : GetDurableExecution réponse avec IncludeExecutionData=false

{
    "DurableExecutionArn": "arn:aws:lambda:us-east-1:111122223333:function:myDurableFunction:execution:exec-abc123",
    "DurableExecutionName": "exec-abc123",
    "FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:myDurableFunction",
    "StartTimestamp": 1733256000,
    "Status": "RUNNING",
    "ExecutionDataIncluded": false,
    "DurableConfig": {
        "ExecutionTimeout": 3600,
        "KMSKeyArn": "arn:aws:kms:us-east-1:111122223333:key/key-id",
        "RetentionPeriodInDays": 30
    }
}

Invocations enchaînées

Lorsqu'une fonction durable utilise l'appel en chaîne pour appeler une autre fonction durable, Lambda traite l'exécution enfant comme une exécution durable indépendante : elle possède son propre ID d'exécution, son propre flux de points de contrôle et sa propre clé gérée par le client. La configuration des clés gérées par le client du parent n'a aucun effet sur les données de l'enfant, et la configuration des clés gérées par le client de l'enfant n'a aucun effet sur les données du parent.

Permissions

Le responsable du service Lambda doit avoir kms:GenerateDataKey et kms:Decrypt sur la clé gérée par le client de la fonction enfant. Si les fonctions parent et enfant utilisent des clés gérées par le client différentes, vous accordez l'accès au principal de service sur chaque touche séparément. Le rôle d'exécution de la fonction parent n'a pas besoin d'autorisations sur la clé gérée par le client de l'enfant.

Identifier quelle clé a chiffré quelle exécution

Les deux GetDurableExecution et ListDurableExecutionsByFunction renvoyez la clé ARN gérée par le client qui a chiffré chaque exécution. Utilisez ces API pour confirmer quelle clé était en vigueur au moment du démarrage de l'exécution d'un parent ou d'un enfant.

Mise en cache des clés de données

Pour réduire le volume d' AWS KMS appels et améliorer la disponibilité en cas d'interruption de service, Lambda met en cache une clé de données générée à partir de votre clé gérée par le client pendant 15 minutes maximum. Lorsque le cache est chaud, Lambda réutilise la même clé de données pour toutes les opérations au cours d'une exécution et pour toutes les exécutions démarrées pendant la fenêtre de cache.

Cost

Per-execution AWS KMS le coût reste faible car Lambda appelle GenerateDataKey au plus une fois par fenêtre de cache, et non une fois par point de contrôle. À des taux de demandes élevés, le coût par exécution diminue encore car un plus grand nombre d'exécutions partagent chaque clé de données mise en cache. Vous êtes facturé pour les AWS KMS appels que Lambda passe réellement, et non pour chaque point de contrôle ou lecture.

Stabilité statique

Les clés de données restent mises en cache pendant 15 minutes au maximum. Les modifications apportées à votre clé prendront effet lors de la prochaine actualisation du cache. Pendant les interruptions de service prolongées, Lambda continue de servir à partir du cache, ce qui permet aux exécutions en cours de fonctionnement.

CloudTrail

La mise en cache des clés de données signifie que vous voyez moins d'GenerateDataKeyévénements CloudTrail que d'exécutions ou de points de contrôle. Voir par Surveillance des touches KMS pour des fonctions durables exemple les événements.

Lorsque la clé gérée par le client n'est pas disponible

Si la clé gérée par le client avec laquelle une exécution a commencé est désactivée, sa suppression est programmée ou son accès est révoqué par le biais de la politique de clé, l'exécution ne peut pas progresser davantage. Au point de contrôle suivant, Lambda échoue à l'exécution avec une erreur qui ne peut pas être réessayée. AWS KMS La restauration de l'accès à la clé ne permet pas de reprendre automatiquement l'exécution. Vous devez démarrer une nouvelle exécution.

Les API qui lisent ou écrivent des charges utiles échouent également lorsque la clé n'est pas disponible. Ils peuvent renvoyer l'une des exceptions suivantes :

La restauration de l'accès à la clé KMS permet à ces API de lecture de réussir à nouveau pour les exécutions qui ont déjà échoué. Les exécutions qui ont échoué restent vouées à l'échec ; vous devez recommencer une nouvelle exécution.

Pour inspecter les métadonnées d'exécution alors que la clé KMS n'est pas disponible, appelez GetDurableExecution withIncludeExecutionData=false. Cela renvoie l'état de l'exécution, les horodatages et DurableConfig (y compris l'ARN de la clé KMS) sans appel. AWS KMS

Comme Lambda met en cache les clés de données, la désactivation d'une clé ne prend pas effet immédiatement. Pour en savoir plus, consultez Mise en cache des clés de données.

Surveillance des touches KMS pour des fonctions durables

Lorsque vous utilisez une clé gérée par le client dotée d'une fonction durable, vous pouvez l'utiliser AWS CloudTrail pour suivre les AWS KMS appels que Lambda passe en votre nom. Pour obtenir des conseils généraux sur la recherche d' AWS KMS événements, consultez la section Activité de AWS KMS l'API de recherche.

Pour vérifier que Lambda utilise votre clé comme prévu, recherchez les champs suivants dans chaque événement :

Les exemples suivants concernent CloudTrail des événements provenant d'un UpdateFunctionConfiguration appel CreateFunction ou qui configure une clé gérée par le client sur une fonction durable. Lambda émet trois AWS KMS appels pour valider la clé : un vrai DescribeKey et lancé à sec. GenerateDataKey Decrypt

Rubriques associées au chiffrement