Utilisez-vous AWS CDK? J'utilisais CFn, mais l'écriture en YAML est devenue beaucoup plus difficile, je suis donc récemment passé à AWS CDK.

Donc, cette fois, j'aimerais écrire comment créer ECR à l'aide d'AWS CDK.

environnement

supposition

Les commandes suivantes sont installées

pipenv
aws-cdk

Structure du répertoire

.
├── Pipfile
├── Pipfile.lock
├── README.md
├── app.py #Script principal CDK pour Python
├── cdk.json #Configuration CDK
├── cdk.out #Le modèle CFn, etc., la sortie de CDK est stockée
├── mypy.ini
├── src
│   ├── __init__.py
│   ├── entity #Stocke la ressource réelle
│   ├── props #Classe de définition de paramètre de ressource
│   └── stack #Stocker la pile CFn
└── tox.ini

Relations de répertoire et de script

props/ -> entity/ -> stack/ -> app.py

En conservant les relations ci-dessus, vous serez plus résistant aux changements et vous pourrez également gérer en modifiant les paramètres de chaque environnement.

Installation

Installez la bibliothèque aws_cdk requise

pipenv install aws_cdk.core aws_cdk.aws_ecr

la mise en oeuvre

props/ecr.py

La bibliothèque aws_cdk pour Python a également une classe Props pour chaque ressource, mais je la trouve personnellement inutilisable, donc je la définis moi-même. Seuls les paramètres nécessaires sont définis ici et les valeurs par défaut sont modifiées par rapport aux valeurs officielles en fonction de l'application.

Dans le cas de CFn, la règle de cycle de vie doit être écrite en texte JSON, mais dans le cas de CDK, c'est assez facile car elle ne transmet la valeur qu'au propadi.

from dataclasses import dataclass
from typing import Optional

from aws_cdk.aws_ecr import TagStatus
from aws_cdk.core import RemovalPolicy

from src.props.base import Base


@dataclass(frozen=True)
class LifecycleRule(Base):
    description: Optional[str] = None
    max_image_count: int = 5
    rule_priority: int = 1
    tag_status: TagStatus = TagStatus.ANY


@dataclass(frozen=True)
class Repository(Base):
    id: str
    repository_name: str
    image_scan_on_push: Optional[bool] = None
    removal_policy: RemovalPolicy = RemovalPolicy.RETAIN

entity/ecr.py

J'écrirai la définition de la ressource que je souhaite créer Cette fois, il est défini dans une classe, mais je pense que vous pouvez l'instancier. Je fais juste ça parce que la classe a l'air mieux personnellement

from typing import List, Optional

from src.entity.base import Base
from src.props.ecr import LifecycleRule, Repository


class EcrBase(Base):
    """Classe de base ECR"""

    repository: Repository
    lifecyle_rules: Optional[List[LifecycleRule]] = None


class SampleEcr(EcrBase):
    """Sample"""

    id = 'SampleEcr'

    repository = Repository(
        id='SampleEcrRepo',
        repository_name='sample'
    )

    lifecyle_rules = [
        LifecycleRule(
            description='Delete more than 10 images',
            max_image_count=10
        )
    ]

stack/ecr.py

Nous définirons la pile pour ECR Fondamentalement, la seule définition de ressource à passer à la classe dans la pile devrait être ʻentity` Après cela, si nécessaire, passons la balise etc. que vous souhaitez définir en commun dans app.py en tant qu'argument

from typing import Any, Type

from aws_cdk import core
from aws_cdk.aws_ecr import Repository

from src.entity.ecr import EcrBase


class EcrStack(core.Stack):
    def __init__(
            self,
            scope: core.Construct,
            entity: Type[EcrBase],
            **kwargs: Any) -> None:
        super().__init__(scope, entity.id, **kwargs)

        repo = Repository(self, **entity.repository.to_dict())

        if entity.lifecyle_rules:
            for rule in entity.lifecyle_rules:
                repo.add_lifecycle_rule(**rule.to_dict())

app.py

Écrivons dans app.py pour déployer la pile écrite dans stack / ecr.py

#!/usr/bin/env python3

from aws_cdk import core

from src.entity.ecr import SampleEcr
from src.stack.ecr import EcrStack


app = core.App()

#Balises à définir pour toutes les ressources
tags = {'CreatedBy': 'iscream'}

EcrStack(app, entity=SampleEcr, tags=tags)

app.synth(skip_validation=False)

Déployer

Il existe deux méthodes de déploiement:

pipenv run cdk deploy SampleEcr

pipenv shell
cdk deploy SampleEcr

Une chose à garder à l'esprit lors du déploiement est d'exécuter la commande cdk dans un environnement virtuel avec pipenv. Si vous l'oubliez, vous obtiendrez l'erreur suivante

Traceback (most recent call last):
  File "app.py", line 3, in <module>
    from aws_cdk import core
ModuleNotFoundError: No module named 'aws_cdk'
Subprocess exited with error 1

en conclusion

Dans le cas de CDK, les ressources peuvent être définies dans le langage de programmation, de sorte que les ressources peuvent être gérées de manière flexible. D'autre part, si le code n'est pas conçu correctement, il deviendra spaghetti, et il sera inflexible et difficile à utiliser. Je ne sais pas si la méthode introduite cette fois est la meilleure pratique, mais je pense que le fonctionnement sera amélioré simplement en gérant les répertoires et les fichiers séparément pour chaque fonction.

CDK est un très bon produit, alors essayez-le !!

Reference

https://github.com/aws/aws-cdk
https://docs.aws.amazon.com/cdk/api/latest/python/modules.html

[AWS] Construire ECR avec AWS CDK