Travailler avec le AWS CDK en Python

Ceci est le guide du AWS CDK développeur de la version 2. L'ancien CDK v1 est entré en maintenance le 1er juin 2022 et a pris fin le 1er juin 2023.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Ceci est le guide du AWS CDK développeur de la version 2. L'ancien CDK v1 est entré en maintenance le 1er juin 2022 et a pris fin le 1er juin 2023.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Python est un langage client entièrement pris en charge AWS Cloud Development Kit (AWS CDK) et est considéré comme stable. Travailler avec le AWS CDK en Python utilise des outils familiers, notamment l'implémentation standard de Python (CPython), les environnements virtuels avec virtualenv et le programme d'installation du package Pythonpip. Les modules composant la bibliothèque AWS Construct sont distribués via pypi.org. La version Python de l'événement utilise AWS CDK des identifiants de type Python (par exemple, les noms de snake_case méthodes).

Vous pouvez utiliser n'importe quel éditeur ou IDE. De nombreux AWS CDK développeurs utilisent Visual Studio Code (ou son équivalent open source VSCodium), qui supporte bien Python via une extension officielle. L'éditeur IDLE inclus dans Python suffira pour démarrer. Les modules Python correspondants AWS CDK contiennent des indications de type, utiles pour un outil de linting ou un IDE qui prend en charge la validation de type.

Commencez avec Python

Pour utiliser le AWS CDK, vous devez disposer d'un AWS compte et d'informations d'identification et avoir installé Node.js et le AWS CDK Toolkit. Consultez Commencer à utiliser le AWS CDK.

AWS CDK Les applications Python nécessitent Python 3.6 ou version ultérieure. Si ce n'est pas déjà fait, téléchargez une version compatible pour votre système d'exploitation sur python.org. Si vous utilisez Linux, votre système est peut-être fourni avec une version compatible, ou vous pouvez l'installer à l'aide du gestionnaire de paquets de votre distribution (yum,apt, etc.). Les utilisateurs de Mac peuvent être intéressés par Homebrew, un gestionnaire de paquets de style Linux pour macOS.

Le programme d'installation du package Python et le gestionnaire d'virtualenvenvironnement virtuel sont également requis. pip Les installations Windows des versions compatibles de Python incluent ces outils. Sous Linux, ils pip virtualenv peuvent être fournis sous forme de packages séparés dans votre gestionnaire de packages. Vous pouvez également les installer à l'aide des commandes suivantes :

python -m ensurepip --upgrade
python -m pip install --upgrade pip
python -m pip install --upgrade virtualenv

Si vous rencontrez une erreur d'autorisation, exécutez les commandes ci-dessus avec l'--userindicateur afin que les modules soient installés dans votre répertoire utilisateur, ou utilisez-les sudo pour obtenir les autorisations nécessaires pour installer les modules à l'échelle du système.

Création d’un projet

Vous créez un nouveau AWS CDK projet en l'appelant cdk init dans un répertoire vide. Utilisez l'--languageoption et spécifiez python :

mkdir my-project
cd my-project
cdk init app --language python

cdk initutilise le nom du dossier du projet pour nommer les différents éléments du projet, notamment les classes, les sous-dossiers et les fichiers. Les traits d'union figurant dans le nom du dossier sont convertis en traits de soulignement. Toutefois, le nom doit sinon prendre la forme d'un identifiant Python ; par exemple, il ne doit pas commencer par un chiffre ni contenir d'espaces.

Pour travailler avec le nouveau projet, activez son environnement virtuel. Cela permet d'installer les dépendances du projet localement dans le dossier du projet, plutôt que globalement.

source .venv/bin/activate

Après avoir activé votre environnement virtuel pour la première fois, installez les dépendances standard de l'application :

python -m pip install -r requirements.txt

Gestion des modules AWS de la bibliothèque Construct

Utilisez le programme d'installation de packages Python pour installer et mettre à jour les modules AWS Construct Library destinés à être utilisés par vos applications, ainsi que par les autres packages dont vous avez besoin. pip pipinstalle également automatiquement les dépendances de ces modules. Si votre système n'est pas reconnu pip comme une commande autonome, invoquez-la pip en tant que module Python, comme ceci :

python -m pip PIP-COMMAND

La plupart AWS CDK des constructions sont incluses. aws-cdk-lib Les modules expérimentaux se trouvent dans des modules distincts nommés commeaws-cdk.SERVICE-NAME.alpha. Le nom du service inclut un préfixe aws. Si vous n'êtes pas sûr du nom d'un module, recherchez-le sur PyPI. Par exemple, la commande ci-dessous installe la AWS CodeStar bibliothèque.

python -m pip install aws-cdk.aws-codestar-alpha

Les constructions de certains services se trouvent dans plusieurs espaces de noms. Par exempleaws-cdk.aws-route53, il existe en outre trois espaces de noms Amazon Route 53 supplémentaires, nommés aws-route53-targetsaws-route53-patterns, etaws-route53resolver.

Les noms utilisés pour importer les modules AWS Construct Library dans votre code Python sont les suivants.

import aws_cdk.aws_s3 as s3
import aws_cdk.aws_lambda as lambda_

Nous recommandons les pratiques suivantes lors de l'importation de AWS CDK classes et de modules AWS Construct Library dans vos applications. Le respect de ces directives vous aidera à rendre votre code cohérent avec AWS CDK les autres applications et à le rendre plus facile à comprendre.

Après avoir installé un module, mettez à jour requirements.txt le fichier de votre projet, qui répertorie les dépendances de votre projet. Il est préférable de le faire manuellement plutôt que d'utiliserpip freeze. pip freezecapture les versions actuelles de tous les modules installés dans votre environnement virtuel Python, ce qui peut être utile lorsque vous regroupez un projet à exécuter ailleurs.

Cependant, vous ne requirements.txt devez généralement répertorier que les dépendances de haut niveau (modules dont dépend directement votre application) et non les dépendances de ces bibliothèques. Cette stratégie simplifie la mise à jour de vos dépendances.

Vous pouvez effectuer des modifications requirements.txt pour autoriser les mises à niveau ; il vous suffit de remplacer le numéro de version == précédent par un numéro de version ~= pour autoriser les mises à niveau vers une version compatible supérieure, ou de supprimer complètement l'exigence de version pour spécifier la dernière version disponible du module.

Après avoir requirements.txt été modifiée de manière appropriée pour autoriser les mises à niveau, émettez cette commande pour mettre à niveau les modules installés de votre projet à tout moment :

pip install --upgrade -r requirements.txt

Gestion des dépendances dans Python

En Python, vous spécifiez les dépendances en les insérant requirements.txt pour les applications ou setup.py pour les bibliothèques de construction. Les dépendances sont ensuite gérées avec l'outil PIP. Le PIP est invoqué de l'une des manières suivantes :

pip command options
python -m pip command options

L'python -m pipinvocation fonctionne sur la plupart des systèmes ; pip nécessite que l'exécutable du PIP se trouve sur le chemin du système. Si pip cela ne fonctionne pas, essayez de le remplacer parpython -m pip.

La cdk init --language python commande crée un environnement virtuel pour votre nouveau projet. Cela permet à chaque projet de disposer de ses propres versions des dépendances, ainsi que d'un requirements.txt fichier de base. Vous devez activer cet environnement virtuel en l'exécutant source .venv/bin/activate chaque fois que vous commencez à travailler sur le projet. Sous Windows, exécutez .\venv\Scripts\activate plutôt

Applications CDK

Voici un exemple de fichier requirements.txt. Comme PIP ne possède pas de fonction de verrouillage des dépendances, nous vous recommandons d'utiliser l'opérateur == pour spécifier les versions exactes de toutes les dépendances, comme indiqué ici.

aws-cdk-lib==2.14.0
aws-cdk.aws-appsync-alpha==2.10.0a0

L'installation d'un module avec pip install ne l'ajoute pas automatiquement àrequirements.txt. Tu dois le faire toi-même. Si vous souhaitez effectuer une mise à niveau vers une version ultérieure d'une dépendance, modifiez son numéro de version dansrequirements.txt.

Pour installer ou mettre à jour les dépendances de votre projet après la création ou la modificationrequirements.txt, exécutez ce qui suit :

python -m pip install -r requirements.txt

Bibliothèques de construction tierces

Dans les bibliothèques, les dépendances sont spécifiées danssetup.py, de sorte que les dépendances transitives sont automatiquement téléchargées lorsque le package est consommé par une application. Dans le cas contraire, chaque application qui souhaite utiliser votre package doit copier vos dépendances dans son propre packagerequirements.txt. Un exemple setup.py est présenté ici.

from setuptools import setup

setup(
  name='my-package',
  version='0.0.1',
  install_requires=[
    'aws-cdk-lib==2.14.0',
  ], 
  ...
)

Pour travailler sur le package à des fins de développement, créez ou activez un environnement virtuel, puis exécutez la commande suivante.

python -m pip install -e .

Bien que PIP installe automatiquement les dépendances transitives, il ne peut y avoir qu'une seule copie installée d'un package. La version spécifiée le plus haut dans l'arborescence des dépendances est sélectionnée ; les applications ont toujours le dernier mot quant à la version des packages à installer.

AWS CDK expressions idiomatiques en Python

Conflits linguistiques

En Python, lambda est un mot-clé de langage, vous ne pouvez donc pas l'utiliser comme nom pour le module de bibliothèque de AWS Lambda construction ou les fonctions Lambda. La convention de Python pour de tels conflits consiste à utiliser un trait de soulignement final, comme danslambda_, dans le nom de la variable.

Par convention, le deuxième argument des AWS CDK constructions est nomméid. Lorsque vous écrivez vos propres piles et constructions, appelez un paramètre id « ombres » la fonction intégrée de Pythonid(), qui renvoie l'identifiant unique d'un objet. Cette fonction n'est pas souvent utilisée, mais si vous en avez besoin dans votre construction, renommez l'argument, par exempleconstruct_id.

Arguments et propriétés

Toutes les classes de la bibliothèque de AWS construction sont instanciées à l'aide de trois arguments : la portée dans laquelle la construction est définie (son parent dans l'arbre de construction), un identifiant, et props, un ensemble de paires clé/valeur que la construction utilise pour configurer les ressources qu'elle crée. D'autres classes et méthodes utilisent également le modèle « bundle of attributes » pour les arguments.

scope et id doivent toujours être transmis en tant qu'arguments positionnels, et non en tant qu'arguments de mot clé, car leurs noms changent si la construction accepte une propriété nommée scope ou id.

En Python, les accessoires sont exprimés sous forme d'arguments de mots clés. Si un argument contient des structures de données imbriquées, celles-ci sont exprimées à l'aide d'une classe qui prend ses propres arguments de mots clés lors de l'instanciation. Le même modèle est appliqué aux autres appels de méthode qui prennent un argument structuré.

Par exemple, dans la add_lifecycle_rule méthode d'un compartiment Amazon S3, la transitions propriété est une liste d'Transitioninstances.

bucket.add_lifecycle_rule(
  transitions=[
    Transition(
      storage_class=StorageClass.GLACIER,
      transition_after=Duration.days(10)
    )
  ]
)

Lorsque vous étendez une classe ou que vous remplacez une méthode, vous souhaiterez peut-être accepter des arguments supplémentaires pour vos propres besoins qui ne sont pas compris par la classe parent. Dans ce cas, vous devez accepter les arguments qui ne vous intéressent pas et utiliser des **kwargs arguments contenant uniquement des mots clés pour accepter les arguments qui vous intéressent. Lorsque vous appelez le constructeur du parent ou la méthode remplacée, transmettez uniquement les arguments attendus (souvent juste). **kwargs La transmission d'arguments auxquels la classe ou la méthode parent ne s'attend pas entraîne une erreur.

class MyConstruct(Construct):
    def __init__(self, id, *, MyProperty=42, **kwargs):
        super().__init__(self, id, **kwargs)
        # ...

Une future version du AWS CDK pourrait par hasard ajouter une nouvelle propriété avec un nom que vous avez utilisé pour votre propre propriété. Cela ne posera aucun problème technique aux utilisateurs de votre construction ou de votre méthode (étant donné que votre propriété n'est pas transmise « en haut de la chaîne », la classe parent ou la méthode remplacée utilisera simplement une valeur par défaut) mais cela peut être source de confusion. Vous pouvez éviter ce problème potentiel en nommant vos propriétés de manière à ce qu'elles appartiennent clairement à votre construction. S'il existe de nombreuses nouvelles propriétés, regroupez-les dans une classe au nom approprié et transmettez-la en tant qu'argument de mot clé unique.

Valeurs manquantes

Les AWS CDK utilisations None pour représenter des valeurs manquantes ou non définies. Lorsque vous travaillez avec**kwargs, utilisez la get() méthode du dictionnaire pour fournir une valeur par défaut si aucune propriété n'est fournie. Évitez d'en utiliserkwargs[...], car cela augmente le KeyError nombre de valeurs manquantes.

encrypted = kwargs.get("encrypted")         # None if no property "encrypted" exists
encrypted = kwargs.get("encrypted", False)  # specify default of False if property is missing

Certaines AWS CDK méthodes (par exemple tryGetContext() pour obtenir une valeur de contexte d'exécution) peuvent être renvoyéesNone, ce que vous devrez vérifier explicitement.

Utilisation d'interfaces

Python ne possède pas de fonctionnalité d'interface comme certains autres langages, bien qu'il possède des classes de base abstraites, qui sont similaires. (Si vous n'êtes pas familier avec les interfaces, Wikipedia propose une bonne introduction.) TypeScript, le langage dans lequel le AWS CDK est implémenté, fournit des interfaces, et les constructions et autres AWS CDK objets nécessitent souvent un objet qui adhère à une interface particulière, plutôt que d'hériter d'une classe particulière. Il AWS CDK fournit donc sa propre fonctionnalité d'interface dans le cadre de la couche JSII.

Pour indiquer qu'une classe implémente une interface particulière, vous pouvez utiliser le @jsii.implements décorateur :

from aws_cdk import IAspect, IConstruct
import jsii

@jsii.implements(IAspect)
class MyAspect():
    def visit(self, node: IConstruct) -> None:
        print("Visited", node.node.path)

Type de pièges

Python utilise le typage dynamique, où toutes les variables peuvent faire référence à une valeur de n'importe quel type. Les paramètres et les valeurs de retour peuvent être annotés avec des types, mais ce sont des « indices » qui ne sont pas appliqués. Cela signifie qu'en Python, il est facile de transmettre le type de valeur incorrect à une AWS CDK construction. Au lieu de recevoir une erreur de type lors de la construction, comme c'est le cas dans un langage à typage statique, vous pouvez obtenir une erreur d'exécution lorsque la couche JSII (qui traduit entre Python et le TypeScript noyau) n'est pas en mesure AWS CDK de gérer le type inattendu.

D'après notre expérience, les erreurs de type commises par les programmeurs Python ont tendance à entrer dans ces catégories.

Les modules AWS CDK Python incluent des annotations de type. Vous pouvez donc utiliser les outils qui les prennent en charge pour vous aider à utiliser les types. Si vous n'utilisez pas un IDE qui les prend en charge, par exemple PyCharm, vous pouvez appeler le validateur de MyPytype comme étape de votre processus de construction. Il existe également des vérificateurs de type d'exécution qui peuvent améliorer les messages d'erreur relatifs aux erreurs liées au type.