Infrastructure as Code: Das Fundament der Plattform
L'Infrastruktur als Code (IaC) und das Prinzip, nach dem die Infrastruktur entsteht Definiert, versioniert und verwaltet durch deklarativen oder imperativen Code und nicht durch manuelle Konfigurationen. Im Kontext des Platform Engineering ist IaC nicht nur eine Best Practice: und eine Grundvoraussetzung für den Aufbau eines IDP, der wiederholbar, skalierbar und überprüfbar ist.
In diesem Artikel vergleichen wir die beiden vorherrschenden Ansätze – Terraform (deklarativ) e Pulumi (Imperativ bei Allzwecksprachen) – und wir werden untersuchen, wie man es umsetzt Richtlinie als Kodex mit OPA und Sentinel, um Compliance und automatisierte Sicherheit zu gewährleisten.
Was Sie Lernen Werden
- Paradigmi IaC: dichiarativo (Terraform/HCL) vs imperativo (Pulumi/TypeScript)
- Statusverwaltung: Remote-Status, Sperren, Notfallwiederherstellung
- Moduli Terraform riutilizzabili e composizione
- Pulumi: IaC mit TypeScript, Python und Go
- Richtlinie als Code: OPA/Rego für Compliance und Sentinel für Terraform Cloud
- Migrationsstrategien zu IaC für bestehende Infrastruktur
Terraform: Der Deklarative Ansatz
Terraform von HashiCorp und das beliebteste IaC-Tool der Welt. Verwenden Sie a deklarative Sprache genannt HCL (HashiCorp-Konfigurationssprache) für Beschreiben Sie den gewünschten Zustand der Infrastruktur. Terraform vergleicht den gewünschten Zustand mit dem aktuellen Zustand und berechnet einen Ausführungsplan, um die Zielkonfiguration zu erreichen.
Die Stärken von Terraform sind:
- Provider ecosystem: supporta centinaia di provider cloud e SaaS (AWS, Azure, GCP, Kubernetes, GitHub, Datadog...)
- Planen Sie vor der Bewerbung: Änderungen vor der Ausführung anzeigen, um das Fehlerrisiko zu verringern
- Staatsverwaltung: Verfolgt den tatsächlichen Zustand Ihrer Infrastruktur, um inkrementelle Aktualisierungen durchzuführen
- Formulare: Wiederverwendbare Komponenten, die komplexe Konfigurationen kapseln
# Terraform: modulo riutilizzabile per microservice infrastructure
# modules/microservice-infra/main.tf
variable "service_name" {
type = string
description = "Nome del microservizio"
}
variable "environment" {
type = string
description = "Environment (dev, staging, production)"
}
variable "cpu_limit" {
type = string
default = "500m"
}
variable "memory_limit" {
type = string
default = "512Mi"
}
# Kubernetes namespace con labels standard
resource "kubernetes_namespace" "service" {
metadata {
name = "${var.service_name}-${var.environment}"
labels = {
"app.kubernetes.io/name" = var.service_name
"app.kubernetes.io/env" = var.environment
"platform.company.io/managed" = "true"
}
}
}
# Database PostgreSQL (RDS)
resource "aws_db_instance" "database" {
identifier = "${var.service_name}-${var.environment}"
engine = "postgres"
engine_version = "15.4"
instance_class = var.environment == "production" ? "db.r6g.large" : "db.t3.micro"
allocated_storage = 20
max_allocated_storage = var.environment == "production" ? 100 : 50
storage_encrypted = true
db_name = replace(var.service_name, "-", "_")
username = "app_user"
password = random_password.db_password.result
backup_retention_period = var.environment == "production" ? 30 : 7
deletion_protection = var.environment == "production"
tags = {
Service = var.service_name
Environment = var.environment
ManagedBy = "terraform"
}
}
# Redis cache (ElastiCache)
resource "aws_elasticache_cluster" "cache" {
cluster_id = "${var.service_name}-${var.environment}"
engine = "redis"
node_type = var.environment == "production" ? "cache.r6g.large" : "cache.t3.micro"
num_cache_nodes = 1
parameter_group_name = "default.redis7"
port = 6379
}
output "namespace" {
value = kubernetes_namespace.service.metadata[0].name
}
output "database_endpoint" {
value = aws_db_instance.database.endpoint
}
output "cache_endpoint" {
value = aws_elasticache_cluster.cache.cache_nodes[0].address
}
Pulumi: IaC mit Allzweck-Programmiersprachen
Pulumi verfolgt einen anderen Ansatz: Anstelle einer dedizierten Sprache (wie HCL) ermöglicht es Ihnen, die Infrastruktur mithilfe von Standardprogrammiersprachen wie zu definieren TypeScript, Python, Go, C# und Java. Das bedeutet, Zugriff auf Konstrukte zu haben wie Schleifen, Bedingungen, Funktionen, Klassen und das gesamte Ökosystem von Bibliotheken der gewählten Sprache.
Die Vorteile von Pulumi sind:
- Vertraute Sprachen: Es ist nicht notwendig, eine neue Sprache zu lernen; Sie nutzen, was das Team bereits weiß
- Native Tests: Unit-Tests und Integrationstests der Infrastruktur mit Standard-Test-Frameworks
- Kraftvolle Abstraktionen: Klassen, Schnittstellen und Komposition zum Erstellen komplexer IaC-Komponenten
- IDE support: autocomplete, type checking e refactoring con i tool del linguaggio
// Pulumi: componente riutilizzabile in TypeScript
// microservice-infra.ts
import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as k8s from "@pulumi/kubernetes";
interface MicroserviceInfraArgs {
serviceName: string;
environment: string;
cpuLimit?: string;
memoryLimit?: string;
enableDatabase?: boolean;
enableCache?: boolean;
}
export class MicroserviceInfra extends pulumi.ComponentResource {
public readonly namespace: k8s.core.v1.Namespace;
public readonly databaseEndpoint?: pulumi.Output<string>;
public readonly cacheEndpoint?: pulumi.Output<string>;
constructor(
name: string,
args: MicroserviceInfraArgs,
opts?: pulumi.ComponentResourceOptions
) {
super("company:platform:MicroserviceInfra", name, {}, opts);
const isProd = args.environment === "production";
// Kubernetes namespace
this.namespace = new k8s.core.v1.Namespace(
`${args.serviceName}-ns`,
{
metadata: {
name: `${args.serviceName}-${args.environment}`,
labels: {
"app.kubernetes.io/name": args.serviceName,
"app.kubernetes.io/env": args.environment,
"platform.company.io/managed": "true",
},
},
},
{ parent: this }
);
// Database condizionale
if (args.enableDatabase !== false) {
const db = new aws.rds.Instance(
`${args.serviceName}-db`,
{
identifier: `${args.serviceName}-${args.environment}`,
engine: "postgres",
engineVersion: "15.4",
instanceClass: isProd ? "db.r6g.large" : "db.t3.micro",
allocatedStorage: 20,
storageEncrypted: true,
deletionProtection: isProd,
},
{ parent: this }
);
this.databaseEndpoint = db.endpoint;
}
this.registerOutputs({
namespaceName: this.namespace.metadata.name,
});
}
}
State-Management
Die Leitung von bleiben und einer der kritischsten Aspekte von IaC. Die Statusdatei enthält die Zuordnung zwischen den im Code definierten Ressourcen und den realen Ressourcen in der Cloud. Eine Geschäftsführung Staatliche Fehler können zu Abweichungen, Konflikten und sogar zum Verlust von Ressourcen führen.
- Remote-Zustand: Der Status muss in einem Remote-Backend (S3, GCS, Azure Blob, Terraform Cloud) gespeichert werden, um von den Teammitgliedern gemeinsam genutzt werden zu können
- Sie sperren: Sperrmechanismus (DynamoDB für AWS, GCS für GCP), um gleichzeitige Änderungen zu verhindern
- Staatsverschlüsselung: Der Staat enthält vertrauliche Informationen und muss im Ruhezustand und bei der Übertragung verschlüsselt werden
- Notfallwiederherstellung: Regelmäßige Zustandssicherungen mit aktivierter Versionierung für den Bucket
Grundlegende Regel
Übertragen Sie die Statusdatei niemals in das Git-Repository. Der Staat enthält Informationen sensibel (Passwörter, Verbindungszeichenfolgen, Schlüssel) und müssen ausschließlich über das Backend verwaltet werden remote mit entsprechender Verschlüsselung und Zugriffskontrolle.
Policy as Code mit OPA und Sentinel
Richtlinie als Kodex und das Prinzip, Organisationsrichtlinien als Code zu definieren versioniert, testbar und automatisch durchsetzbar. Im IaC-Kontext werden Richtlinien überprüft dass die definierte Infrastruktur zunächst Sicherheits-, Compliance- und Kostenanforderungen erfüllt des Einsatzes.
- OPA (Open Policy Agent): Allzweck-Richtlinien-Engine mit Rego-Sprache. Kann Terraform-Pläne, Kubernetes-Manifeste und API-Anfragen validieren
- Wächter: HashiCorp-Richtlinien-Framework in Terraform Cloud/Enterprise integriert. Verwenden Sie eine dedizierte Sprache, die für Infrastrukturrichtlinien optimiert ist
- Kyverno: Native Kubernetes-Richtlinien-Engine, die YAML zum Definieren von Richtlinien verwendet (einfacher als OPA für K8s-spezifische Anwendungsfälle)
# OPA/Rego: policy per validare Terraform plans
# policy/terraform/mandatory_tags.rego
package terraform.mandatory_tags
import rego.v1
# Tutti i resource devono avere i tag obbligatori
mandatory_tags := ["Environment", "Service", "ManagedBy", "Team"]
# Trova risorse senza tag obbligatori
deny contains msg if {
resource := input.planned_values.root_module.resources[_]
tags := object.get(resource.values, "tags", {})
required_tag := mandatory_tags[_]
not tags[required_tag]
msg := sprintf(
"Resource '%s' manca il tag obbligatorio '%s'",
[resource.address, required_tag]
)
}
# Database in produzione deve avere encryption abilitata
deny contains msg if {
resource := input.planned_values.root_module.resources[_]
resource.type == "aws_db_instance"
resource.values.storage_encrypted != true
msg := sprintf(
"Database '%s' deve avere storage_encrypted = true",
[resource.address]
)
}
# Nessuna risorsa pubblica senza approvazione
deny contains msg if {
resource := input.planned_values.root_module.resources[_]
resource.type == "aws_s3_bucket"
acl := object.get(resource.values, "acl", "private")
acl == "public-read"
msg := sprintf(
"S3 bucket '%s' non può essere pubblico senza approvazione",
[resource.address]
)
}
GitOps und PR-basierte Workflows
Die Integration von IaC mit Workflow GitOps und für einen reifen Binnenvertriebenen unerlässlich. Das effektivste Muster ist das PR-basierter Workflow: Alle Änderungen an der Infrastruktur erfolgt über einen Pull Request, der vor der Zusammenführung automatisch validiert wird.
- Atlantis: Tool, das den Terraform-Workflow bei Pull Request automatisiert (automatischer Plan, Anwendung nach Genehmigung)
- Weltraumlift: SaaS-Plattform für IaC-Management mit Richtlinie, Drifterkennung und Modulregistrierung
- Env0: piattaforma che aggiunge governance, costi e TTL agli ambienti IaC
Der Vorteil des PR-basierten Workflows ist der Rückverfolgbarkeit vollständig: jede Änderung in die Infrastruktur integriert und in einer PR mit Prüfung, Kommentaren und Freigabe dokumentiert. Das befriedigt Audit- und Compliance-Anforderungen auf natürliche Weise erfüllen.
Migrationsstrategien
Migrieren Sie eine vorhandene Infrastruktur (manuell oder mit Ad-hoc-Skripts erstellt) zu IaC Es ist ein Prozess, der Planung und Schrittweise erfordert:
- Phase 1 – Importieren: Vorhandene Ressourcen in den Terraform-Status importieren, ohne sie zu ändern
- Schritt 2 – Kodifizieren: Schreiben Sie den IaC-Code, der die importierten Ressourcen beschreibt, und stellen Sie sicher, dass der Plan keine Änderungen aufweist
- Phase 3 – Standardisieren: progressive Umgestaltung hin zu gemeinsam genutzten Modulen und Namenskonventionen
- Schritt 4 – Automatisieren: Integration mit CI/CD für automatische Anwendung und Richtliniendurchsetzung
Migrationstipp
Versuchen Sie nicht, Ihre gesamte Infrastruktur auf einen Schlag zu migrieren. Beginnen Sie mit den einfachsten Komponenten und geringes Risiko (S3-Bucket, DNS-Einträge, IAM-Richtlinien), Erfahrung und Vertrauen gewinnen, Fahren Sie dann mit den kritischsten Ressourcen fort (Datenbank, Kubernetes-Cluster, Netzwerk).