Verwaltung mehrerer Umgebungen im AWS CDK mit YAML-Konfigurationsdateien

Ein spezieller Bereich, in dem die Bereitstellung von Infrastructure as Code von immenser Bedeutung ist, ist der Kontext einer DTAP-Umgebung (Entwicklung, Test, Abnahme, Produktion). Die DTAP-Straße bezieht sich auf das Fortschreiten der Software durch verschiedene Phasen, angefangen bei der Entwicklung und den Tests bis hin zur endgültigen Bereitstellung in der Produktionsumgebung. Durch die Einführung von IaC-Prinzipien in der gesamten DTAP-Straße können Unternehmen zahlreiche Vorteile nutzen und die Herausforderungen überwinden, die mit der manuellen Bereitstellung und Verwaltung der Infrastruktur verbunden sind.

Aus der Programmierperspektive gibt es mehrere Schlüsseltechnologien und -praktiken für die effektive Verwaltung mehrerer Umgebungen mit IaC.

Lassen Sie uns diese erkunden:

• Tools zur Konfigurationsverwaltung: Konfigurationsmanagement-Tools wie Ansible, Chef oder Puppet werden bei IaC häufig eingesetzt, um die Bereitstellung und Konfiguration von Infrastrukturressourcen in mehreren Umgebungen zu automatisieren. Mit diesen Tools können Sie Infrastrukturkonfigurationen als Code in einer deklarativen oder imperativen Sprache definieren. Indem Sie Infrastrukturkonfigurationen zentral definieren und pflegen, können Sie sie leicht verwalten und in verschiedenen Umgebungen replizieren.
• Tools für die Infrastrukturbereitstellung: Tools für die Infrastrukturbereitstellung wie Terraform oder AWS CloudFormation und das Cloud Development Kit (CDK) ermöglichen Ihnen die programmatische Definition und Bereitstellung von Infrastrukturressourcen. Diese Tools verwenden domänenspezifische Sprachen (DSLs) oder Konfigurationsdateien, um den gewünschten Zustand Ihrer Infrastruktur zu beschreiben. Mit diesen Tools können Sie Ressourcen wie virtuelle Maschinen, Netzwerke, Speicher, Load Balancer und mehr definieren und sie mit einem einzigen Befehl konsistent in mehreren Umgebungen bereitstellen.
• Versionskontrollsysteme: Versionskontrollsysteme wie Git spielen bei der Verwaltung von Infrastructure as Code eine entscheidende Rolle. Indem Sie Infrastrukturkonfigurationen und Bereitstellungsskripte unter Versionskontrolle halten, können Sie Änderungen nachverfolgen, mit Teamkollegen zusammenarbeiten und bei Bedarf problemlos zu früheren Versionen zurückkehren. Versionskontrollsysteme ermöglichen es Ihnen auch, verschiedene Zweige oder Umgebungen zu verwalten, so dass Sie Infrastrukturänderungen isoliert entwickeln und testen können, bevor Sie sie in die Produktion einbringen.
• Umgebungsvariablen und Parametrisierung: Um unterschiedliche Konfigurationen für jede Umgebung zu berücksichtigen, ist es wichtig, Umgebungsvariablen und Parametrisierungstechniken zu nutzen. Mit diesen Techniken können Sie wiederverwendbare Infrastrukturvorlagen definieren und während des Bereitstellungsprozesses dynamisch umgebungsspezifische Werte einfügen. Sie können beispielsweise Variablen verwenden, um die Anzahl der Instanzen, Netzwerkkonfigurationen oder Anmeldeinformationen für jede Umgebung festzulegen, was die Verwaltung und Skalierung von Umgebungen mit minimalen manuellen Eingriffen erleichtert.
• Kontinuierliche Integration und Bereitstellung (CI/CD) Pipelines: Die Implementierung von CI/CD-Pipelines ist entscheidend für die Verwaltung mehrerer Umgebungen mit IaC. CI/CD-Pipelines ermöglichen die Automatisierung von Build-, Test- und Bereitstellungsprozessen und sorgen für konsistente und zuverlässige Bereitstellungen in verschiedenen Umgebungen. Indem Sie Ihren Infrastrukturcode in die CI/CD-Pipeline integrieren, können Sie bei jeder Änderung automatisch Infrastrukturaktualisierungen oder -bereitstellungen auslösen, was manuelle Eingriffe reduziert und Fehler minimiert.

Wenn Sie sich näher mit dem Konzept der Umgebungsvariablen und der Parametrisierung beschäftigen und sich dabei auf das AWS CDK konzentrieren, können Sie mit YAML die Konfiguration mehrerer Umgebungen innerhalb einer einzigen Codebasis verwalten. Aber warum YAML?

Es gibt eine Reihe von Gründen für die Verwendung von YAML zur Verwaltung mehrerer Umgebungen innerhalb des AWS CDK:

1. Einfachheit und Lesbarkeit: YAML bietet eine einfache und für Menschen lesbare Syntax, die es Entwicklern, DevOps-Ingenieuren und Stakeholdern erleichtert, die Konfiguration des Infrastrukturcodes zu verstehen und damit zu arbeiten. Die auf Einrückungen basierende Struktur von YAML macht die Definition von Ressourcenkonfigurationen und -beziehungen intuitiv, reduziert die Komplexität und bietet ein einziges Konfigurationsfenster pro Umgebung.
2. Integration mit AWS CDK: Das AWS CDK kann mit YAML-Dateien integriert werden, indem es die YAML-Dateien parst und die Informationen in nativen Datenstrukturen speichert, die Schlüssel-Wert-Paare enthalten können.

Gehen wir von einem AWS CDK-Projekt in einer beliebigen Sprache aus und betrachten wir die folgende Struktur für die Konfiguration unserer Umgebungen:

├── config
│   ├── development.yaml
│   ├── test.yaml
│   ├── acceptance.yaml
│   ├── production.yaml
└──

Für AWS enthält der Inhalt jeder Datei in der Regel mindestens die Konto-ID, die Region und, falls wir VPCs erstellen, den CIDR-Block, der für jede Umgebung verwendet wird.

account_id: '123456789'
region: eu-west-1

cidr: 10.0.0.0/16

Sehen wir uns an, wie wir die vorherigen Informationen pro Umgebung auswerten können, indem wir in die Details eintauchen, wie wir dies im AWS CDK mit Python und Go implementieren.

Definition der Umgebung

Beim Synthetisieren und Bereitstellen von AWS CDK-Code können wir Laufzeitkontext übergeben. Kontextwerte sind Schlüssel-Wert-Paare, die mit einer App, einem Stack oder einem Konstrukt verknüpft werden können. Sie können Ihrer Anwendung aus einer Datei übergeben werden (normalerweise entweder cdk.json oder cdk.context.json in Ihrem Projektverzeichnis) oder über die Befehlszeile. Weitere Informationen zum Laufzeitkontext für das AWS CDK finden Sie hier.

Sie können zum Beispiel unser CDK-Projekt mit dem folgenden Befehl synthetisieren:

cdk synth --context environment=development

Die obige Methode synthetisiert den CloudFormation-Code und übergibt der CDK-App das Schlüssel-Wert-Paar environment: development.

Wir werden diesen Ansatz verwenden, um die Umgebung zu definieren, die wir synthetisieren oder bereitstellen möchten. Dies kann für jede Umgebung in einer potenziellen CI/CD-Pipeline konfiguriert werden, die für die Bereitstellung Ihrer Infrastruktur verwendet werden soll.

Parsen der YAML-Konfiguration im AWS CDK für Python

Beginnen wir mit der Erstellung eines Konfigurationsparsers. Dazu erstellen wir eine Datei und eine Config Klasse. Ein Beispiel für die Implementierung einer solchen Klasse sehen Sie unten.

import yaml
from yaml.loader import SafeLoader

class Config:

    _environment = 'development'
    data = []

    def __init__(self, environment) -> None:
        self._environment = environment
        self.load()

    def load(self) -> dict:
        with open(f'config/{self._environment}.yaml') as f:
            self.data = yaml.load(f, Loader=SafeLoader)
        return self.data

    def get(self, key):
        return self.data[key]

 

Indem wir den Kontext nutzen, den wir zuvor besprochen haben, können wir unseren CDK-Stack wie folgt in app.py instanziieren.

from helper import config

conf = config.Config(app.node.try_get_context('environment'))
stack = NameCdkStack(app, "NameCdkStack",
    env=cdk.Environment(account=conf.get('account_id'), region=conf.get('region')),
)

Ähnlich wie oben können wir alle anderen Werte analysieren, die wir in der Konfiguration speichern möchten, einschließlich des CIDR-Blocks.

Parsen der YAML-Konfiguration im AWS CDK für Go

Ähnlich wie im Python-Beispiel werden wir eine Config-Funktion, unseren Konfigurationsparser, erstellen. Dazu erstellen wir eine Datei und erstellen dort unsere Config-Funktion. Ein Beispiel für die Implementierung einer solchen Klasse sehen Sie unten.

package helper

import (
    "gopkg.in/yaml.v3"
)

type conf struct {
    AccountID string yaml:"account_id"
    Region    string yaml:"region"
    CIDR      string yaml:"cidr"
}

func Config(yamlFile []byte) conf {
    var c conf
    yaml.Unmarshal(yamlFile, &c)

    return c
}

Indem wir den Kontext nutzen, den wir zuvor besprochen haben, können wir unseren CDK-Stack in name-cdk.go wie folgt definieren.

package main

import (
    "io/ioutil"
    "name-cdk/helper"
    "log"
    "reflect"

    "github.com/aws/aws-cdk-go/awscdk/v2"
    "github.com/aws/constructs-go/constructs/v10"
    "github.com/aws/jsii-runtime-go"
)

...

func main() {
    defer jsii.Close()

    app := awscdk.NewApp(nil)
    // get environment from context
    envName := app.Node().GetContext(jsii.String("environment"))

    NameStack(app, "NameStack", &NameStackProps{
        awscdk.StackProps{
            Env: env(reflect.ValueOf(envName).String()),
        },
    })

    app.Synth(nil)
}

func env(environment string) *awscdk.Environment {
    return &awscdk.Environment{
        Account: jsii.String(config.AccountID),
        Region:  jsii.String(config.Region),
    }
}

Fazit

Die Verwendung von YAML kann viele gängige Konfigurationsaufgaben vereinfachen, die in Ihrer AWS CDK-Codebasis durchgeführt werden müssen, ohne dass Sie den Code anfassen müssen. Gleichzeitig wird die gesamte Konfiguration in einem praktischen Format im selben Repository verwaltet. Sie können die oben gezeigten Codeschnipsel verwenden, um mit Ihrer Implementierung des AWS CDK zu beginnen.

Bild von vectorjuice auf Freepik.