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 en cas d'échec 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 de contrôle de rotation, de visibilité des audits ou de conformité. Avec une clé gérée par le client, seuls les principaux que vous autorisez peuvent lire les données d'exécution.

Comment fonctionne le chiffrement

Une exécution durable Lambda 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é par le client

La configuration du chiffrement par clé géré 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 le chiffrement symétrique des clés KMS dans la même AWS région que la fonction. Cross-Region les touches 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 de chiffrement symétriques 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 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'invocation 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 uniquement référence à la clé KMS à laquelle la politique est attachée, et non à toutes les clés KMS de votre compte.

La politique clé d'une fonction durable accorde à chaque principal uniquement les AWS KMS actions dont il a besoin, définies par l'ARN du service et de la fonction. Les sections suivantes décrivent les instructions, les conditions et 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 instructions 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 politique clé dans le Guide du AWS Key Management Service développeur.

Configuration d'une clé gérée par le client sur une fonction durable

Vous configurez la clé gérée par le client pour des données d'exécution durables via le KMSKeyArn champ de l'DurableConfigobjet. Réglez-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 requête. Dans IncludeExecutionData ce 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.

Dans IncludeExecutionData ce casfalse, 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 à la clé ARN gérée par le client utilisée par l'exécution. IncludeExecutionDataest défini par défaut surfalse, 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
    }
}

Invoques enchaînées

Lorsqu'une fonction durable utilise un appel enchaîné pour appeler une autre fonction durable, Lambda traite l'exécution enfant comme une exécution durable indépendante : elle possède son propre identifiant 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 au principal du service l'accès à chaque clé 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 l'ARN de la clé gérée par le client qui a chiffré chaque exécution. Utilisez ces API pour vérifier quelle clé était active au début 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 entre les opérations d'une exécution et entre 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. Lorsque les taux de demandes sont é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 chaque lecture.

Stabilité statique

Les clés de données restent en cache pendant 15 minutes maximum. Les modifications apportées à votre clé prennent 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 de poursuivre les exécutions en cours.

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 clés 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 débuté est désactivée, si sa suppression est planifiée ou si son accès est révoqué par le biais de la politique des clés, l'exécution ne peut pas progresser davantage. Au point de contrôle suivant, Lambda échoue à l'exécution avec une AWS KMS erreur non réessayable. Le rétablissement de l'accès à la clé ne reprend pas automatiquement l'exécution. Vous devez lancer 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 échouées restent des échecs ; vous devez recommencer une nouvelle exécution.

Pour inspecter les métadonnées d'exécution lorsque la clé KMS n'est pas disponible, appelez GetDurableExecution leIncludeExecutionData=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 clés 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 CloudTrailpour suivre les AWS KMS appels que Lambda passe en votre nom. Pour obtenir des conseils généraux sur les AWS KMS événements de recherche, consultez la section Activité des AWS KMS 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 sont CloudTrail des événements issus 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é : une clé réelleDescribeKey, une clé à sec GenerateDataKey et. Decrypt

Sujets de chiffrement connexes