Einhaltung von Richtlinien mit OPA und Terraform: Ein praktischer Leitfaden


Bicycle

In der Welt der Infrastruktur als Code (IaC) kann die Einhaltung von Vorschriften und Sicherheit eine Herausforderung darstellen. Hier kommen Open Policy Agent (OPA) und Terraform ins Spiel. Durch die Integration von OPA-Richtlinien mit Terraform können Sie die Einhaltung von Vorschriften und Best Practices für die Sicherheit automatisch durchsetzen. In diesem Artikel werden wir untersuchen, wie OPA mit Terraform verwendet wird, und Beispiele bereitstellen, um häufige Anwendungsfälle zu demonstrieren.

Was ist Open Policy Agent (OPA)?

Open Policy Agent (OPA) ist eine Open-Source-Richtlinien-Engine, die es Ihnen ermöglicht, Richtlinien für verschiedene Systeme zu definieren und durchzusetzen. OPA verwendet eine deklarative Hochsprache namens Rego, um Richtlinien zu schreiben. OPA kann mit verschiedenen Tools und Diensten integriert werden, darunter Kubernetes, Microservices, CI/CD-Pipelines und, wie wir sehen werden, Terraform.

Was ist Terraform?

Terraform ist ein Open-Source-Tool von HashiCorp, mit dem Sie Ihre Infrastruktur als Code definieren und verwalten können. Mit Terraform können Sie Ihre Infrastruktur mithilfe einer hochgradig konfigurierbaren Sprache beschreiben und diese Konfiguration dann verwenden, um Ihre Infrastruktur zu erstellen, zu aktualisieren und zu versionieren.

Warum OPA mit Terraform kombinieren?

Die Integration von OPA mit Terraform ermöglicht es Ihnen, Richtlinien für Ihren Infrastruktur-Code durchzusetzen, bevor er bereitgestellt wird. Dies stellt sicher, dass Ihre Infrastruktur den Compliance-, Sicherheits- und Betriebs Best Practices entspricht, wodurch das Risiko von Fehlkonfigurationen und Richtlinienverstößen verringert wird.

OPA-Policies für Terraform schreiben

OPA-Richtlinien werden in Rego, einer hochgradig deklarativen Sprache, geschrieben. Rego-Richtlinien sind in Paketen organisiert, und jedes Paket kann mehrere Regeln enthalten. Hier ist ein Beispiel für eine einfache OPA-Richtlinie, die eine Mindest-Terraform-Version erzwingt:

 1package terraform.module
 2
 3import input as tfplan
 4import rego.v1
 5
 6minimum_terraform := "1.6.0"
 7
 8deny contains msg if {
 9    v := tfplan.terraform_version
10    semver.compare(v, minimum_terraform) < 0
11
12    msg := sprintf("terraform version must be at least %v - %v is not supported", [minimum_terraform, v])
13}

Um unsere OPA-Richtlinie zu überprüfen, können wir das OPA-CLI verwenden, um die Richtliniendatei zu prüfen:

1$ opa check policies/minimal_terraform_version.rego

OPA mit Terraform integrieren

Um OPA mit Terraform zu integrieren, müssen wir einen Terraform-Plan erstellen und ihn in das JSON-Format konvertieren. Anschließend können wir die OPA-Richtlinie gegen den JSON-Plan auswerten. Hier ist ein Beispiel, wie man mit Terraform einen S3-Bucket mit Eigentumskontrollen und einer ACL erstellt:

 1resource "aws_s3_bucket" "example" {
 2  bucket = "my-tf-example-bucket"
 3}
 4
 5resource "aws_s3_bucket_ownership_controls" "example" {
 6  bucket = aws_s3_bucket.example.id
 7  rule {
 8    object_ownership = "BucketOwnerPreferred"
 9  }
10}
11
12resource "aws_s3_bucket_acl" "example" {
13  depends_on = [aws_s3_bucket_ownership_controls.example]
14
15  bucket = aws_s3_bucket.example.id
16  acl    = "public-read"
17}
  1. Erstellen eines Terraform-Plans
1$ terraform plan -out tfplan
  1. Konvertieren des Plans in JSON
1$ terraform show -json tfplan > tfplan.json
  1. Ausführen der OPA-Auswertung
 1$ opa eval --data policies/minimal_terraform_version.rego --input tfplan.json "data.terraform.module.deny"
 2
 3{
 4  "result": [
 5    {
 6      "expressions": [
 7        {
 8          "value": [],
 9          "text": "data.terraform.module.deny",
10          "location": {
11            "row": 1,
12            "col": 1
13          }
14        }
15      ]
16    }
17  ]
18}

Beispiel: Durchsetzen von S3-Bucket-Richtlinien

Sie können auch OPA-Richtlinien verwenden, um S3-Bucket-Richtlinien zu überprüfen. Hier ist ein Beispiel für eine Richtlinie, die erzwingt, dass S3-Buckets spezifische ACLs haben:

 1package terraform.module
 2
 3import input as tfplan
 4import rego.v1
 5
 6allowed_s3_acls := ["private", "authenticated-read"]
 7
 8deny contains msg if {
 9    r := tfplan.resource_changes[_]
10    r.type == "aws_s3_bucket_acl"
11    not r.change.after.acl in allowed_s3_acls
12
13    msg := sprintf("%v - s3 buckets must have acls that are in %v", [r.address, allowed_s3_acls])
14}

Um die Richtlinie gegen den zuvor erstellten Plan auszuwerten, müssen Sie nur den folgenden Befehl ausführen:

 1$ opa eval --data policies/s3_bucket_acl.rego --input tfplan.json "data.terraform.module.deny"
 2
 3{
 4  "result": [
 5    {
 6      "expressions": [
 7        {
 8          "value": [
 9            "aws_s3_bucket_acl.example - s3 buckets must have acls that are in [\"private\", \"authenticated-read\"]"
10          ],
11          "text": "data.terraform.module.deny",
12          "location": {
13            "row": 1,
14            "col": 1
15          }
16        }
17      ]
18    }
19  ]
20}

Beispiel: Durchsetzen von Sicherheitsgruppenrichtlinien

Lassen Sie uns eine Richtlinie durchsetzen, um sicherzustellen, dass keine Sicherheitsgruppe SSH-Zugriff von überall erlaubt.

 1package terraform.module
 2
 3import rego.v1
 4import input as tfplan
 5
 6disallowed_cidrs := ["0.0.0.0/0", "::/0"]
 7
 8deny contains msg if {
 9    r := tfplan.resource_changes[_]
10    r.type in ["aws_security_group_rule", "aws_security_group"]
11    valid_port(r.change.after.ingress[_])
12    invalid_cidr(r.change.after.ingress[_])
13
14    msg := sprintf("%v has 0.0.0.0/0 as allowed ingress for SSH / Port 22", [r.address])
15}
16
17valid_port(ingress) if ingress.from_port == 22
18valid_port(ingress) if ingress.to_port == 22
19
20invalid_cidr(ingress) if ingress.cidr_blocks[_] in disallowed_cidrs
21invalid_cidr(ingress) if ingress.ipv6_cidr_blocks[_] in disallowed_cidrs

Hier ist eine Beispielkonfiguration für eine AWS-Sicherheitsgruppe:

 1resource "aws_security_group" "example" {
 2  name        = "example-sg"
 3  description = "Beispiel Sicherheitsgruppe"
 4
 5  ingress {
 6    from_port   = 22
 7    to_port     = 22
 8    protocol    = "tcp"
 9    cidr_blocks = ["0.0.0.0/0"]
10  }
11}
12
13resource "aws_security_group_rule" "example" {
14  type              = "ingress"
15  from_port         = 22
16  to_port           = 22
17  protocol          = "tcp"
18  ipv6_cidr_blocks = [ "::/0" ]
19  security_group_id = aws_security_group.example.id
20}
  1. Erstellen und Anzeigen des Plans:
1$ terraform plan -out=tfplan
2$ terraform show -json tfplan > tfplan.json
  1. Scannen mit OPA:
 1$ opa eval --data policies/security_group_ssh.rego --input tfplan.json "data.terraform.module.deny"
 2
 3{
 4  "result": [
 5    {
 6      "expressions": [
 7        {
 8          "value": [
 9            "aws_security_group.example has 0.0.0.0/0 as allowed ingress for SSH / Port 22"
10          ],
11          "text": "data.terraform.module.deny",
12          "location": {
13            "row": 1,
14            "col": 1
15          }
16        }
17      ]
18    }
19  ]
20}

Ausführen aller OPA-Richtlinien

In den vorherigen Beispielen haben wir einzelne Richtlinien gegen den Terraform-Plan ausgewertet. Sie können jedoch auch mehrere Richtlinien zusammenfassen und alle auf einmal auswerten. Hier ist, wie Sie das tun können:

 1$ terraform plan -out=tfplan
 2$ terraform show -json tfplan > tfplan.json
 3$ opa exec --decision terraform/module/deny --bundle policies/ tfplan.json
 4{
 5  "result": [
 6    {
 7      "path": "tfplan.json",
 8      "result": [
 9        "aws_s3_bucket_acl.example - s3 buckets must have acls that are in [\"private\", \"authenticated-read\"]",
10        "aws_security_group.example has 0.0.0.0/0 as allowed ingress for SSH / Port 22"
11      ]
12    }
13  ]
14}

Fazit

Die Integration von OPA mit Terraform bietet einen leistungsstarken Mechanismus zur Durchsetzung von Compliance-, Sicherheits- und Betriebsbest Practices in Ihrer Infrastruktur als Code. Durch die Definition von Richtlinien in OPA und die Validierung von Terraform-Konfigurationen gegen diese Richtlinien können Sie sicherstellen, dass Ihre Infrastruktur sicher und konform bleibt.

Mit den bereitgestellten Beispielen können Sie beginnen, Ihre eigenen Richtlinien zu erstellen, um die Anforderungen Ihrer Organisation zu erfüllen. Viel Spaß beim Umsetzen von OPA-Richtlinien in Ihren Terraform-Workflows!

Zurück Unsere Trainings entdecken

Wir sind für Sie da

Sie interessieren sich für unsere Trainings oder haben einfach eine Frage, die beantwortet werden muss? Sie können uns jederzeit kontaktieren! Wir werden unser Bestes tun, um alle Ihre Fragen zu beantworten.

Hier kontaktieren