Verwenden Sie AWS CDK? Ich habe CFn verwendet, aber das Schreiben in YAML ist viel schwieriger geworden. Deshalb bin ich kürzlich zum AWS CDK gewechselt.

Dieses Mal möchte ich schreiben, wie ECR mit AWS CDK erstellt wird.

Umgebung

Annahme

Die folgenden Befehle werden installiert

pipenv
aws-cdk

Verzeichnisaufbau

.
├── Pipfile
├── Pipfile.lock
├── README.md
├── app.py #CDK-Hauptskript für Python
├── cdk.json #CDK-Konfiguration
├── cdk.out #Die vom CDK ausgegebene CFn-Vorlage usw. wird gespeichert
├── mypy.ini
├── src
│   ├── __init__.py
│   ├── entity #Speichert die eigentliche Ressource
│   ├── props #Definitionsklasse für Ressourcenparameter
│   └── stack #CFn-Stapel speichern
└── tox.ini

Verzeichnis- und Skriptbeziehungen

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

Durch Beibehalten der oben genannten Beziehungen sind Sie widerstandsfähiger gegen Änderungen und können dies auch durch Ändern der Parameter für jede Umgebung verwalten.

Installation

Installieren Sie die erforderliche aws_cdk-Bibliothek

pipenv install aws_cdk.core aws_cdk.aws_ecr

Implementierung

props/ecr.py

Die aws_cdk-Bibliothek für Python hat auch eine Props-Klasse für jede Ressource, aber ich persönlich finde sie unbrauchbar, also definiere ich sie selbst. Hier werden nur die erforderlichen Parameter eingestellt und die Standardwerte werden je nach Anwendung von den offiziellen Werten geändert.

Im Fall von CFn muss die Lebenszyklusregel in JSON-Text geschrieben werden, im Fall von CDK ist dies jedoch recht einfach, da der Wert nur an den richtigen übergeben wird

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

Ich werde die Definition der Ressource schreiben, die ich erstellen möchte Dieses Mal ist es in einer Klasse definiert, aber ich denke, Sie können es instanziieren. Ich mache das einfach, weil die Klasse persönlich besser aussieht

from typing import List, Optional

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


class EcrBase(Base):
    """ECR-Basisklasse"""

    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

Wir werden den Stack für ECR definieren Die einzige Ressourcendefinition, die Sie an eine Klasse im Stapel übergeben, sollte grundsätzlich "Entität" sein Lassen Sie uns danach bei Bedarf das Tag usw., das Sie in app.py gemeinsam festlegen möchten, als Argument übergeben

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

Schreiben wir in app.py, um den in stack / ecr.py geschriebenen Stack bereitzustellen

#!/usr/bin/env python3

from aws_cdk import core

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


app = core.App()

#Tags, die für alle Ressourcen festgelegt werden sollen
tags = {'CreatedBy': 'iscream'}

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

app.synth(skip_validation=False)

Bereitstellen

Es gibt zwei Bereitstellungsmethoden:

pipenv run cdk deploy SampleEcr

pipenv shell
cdk deploy SampleEcr

Bei der Bereitstellung müssen Sie den Befehl cdk in einer virtuellen Umgebung mit pipenv ausführen. Wenn Sie es vergessen, wird der folgende Fehler angezeigt

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

abschließend

Im Fall von CDK können Ressourcen in der Programmiersprache definiert werden, sodass Ressourcen flexibel verwaltet werden können. Wenn der Code jedoch nicht richtig entworfen wurde, wird er zu Spaghetti, und er ist unflexibel und schwer zu bedienen. Ich weiß nicht, ob die diesmal eingeführte Methode die beste Vorgehensweise ist, aber ich denke, dass der Vorgang verbessert wird, indem die Verzeichnisse und Dateien für jede Funktion separat verwaltet werden.

CDK ist ein ziemlich gutes Produkt, also probieren Sie es bitte aus!

Reference

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

[PYTHON] [AWS] ECR mit AWS CDK erstellen