Werkzeugentscheidung

Terraform oder OpenTofu: Was die Lizenzänderung für dein Unternehmen bedeutet

Wer Terraform für die eigene Infrastruktur einsetzt, dem verbietet die Business Source License nichts. Die Entscheidung fällt deshalb nicht juristisch, sondern über Funktionsstand, Werkzeugkette und die Frage, wem ihr die nächsten Jahre folgen wollt. OpenTofu ist technisch angekommen, der Wechsel dauert bei sauberem Code einen Nachmittag. Teuer wird nur der Rückweg, wenn ihr ihn euch verbaut.

5 Kapitel mit allen Befehlen
Zwei IT-Entscheider vergleichen Plattformoptionen an einem großen Bildschirm
Seit 1997 am Markt Präsenz & Live-Online 4,9 aus 503 Google-Bewertungen Auch Inhouse für dein Team
Worum es geht

Warum die Frage gerade wieder auf dem Tisch liegt

Im August 2023 hat HashiCorp Terraform von der Mozilla Public License auf die Business Source License umgestellt. Wenige Wochen später entstand OpenTofu als Fork des letzten frei lizenzierten Standes und landete unter dem Dach der Linux Foundation. Seit die Übernahme von HashiCorp durch IBM abgeschlossen ist, kommt die Frage in deutschen Unternehmen ein zweites Mal hoch, diesmal nicht aus der Technik, sondern aus Einkauf und Rechtsabteilung. Dort will jemand eine belastbare Aussage, bevor der nächste Rahmenvertrag unterschrieben wird.

Die meiste Verunsicherung entsteht aus einer Verkürzung. Aus dem Satz, Terraform sei nicht mehr Open Source, wird im Flurfunk schnell die Behauptung, man dürfe es nicht mehr einsetzen. Das ist falsch. Die Business Source License erlaubt den produktiven Einsatz ausdrücklich und untersagt nur, das Werkzeug Dritten als konkurrierendes gehostetes oder eingebettetes Angebot bereitzustellen. Wer damit die eigene Infrastruktur baut, fällt nicht darunter. Betroffen sind Anbieter, die Terraform zum Kern eines eigenen Produkts machen.

Die realen Risiken liegen woanders. Die offizielle Terraform Registry darf laut Nutzungsbedingungen nicht von fremden Clients bedient werden, weshalb OpenTofu eine eigene Registry betreibt. Die Funktionsstände laufen seit dem Fork auseinander, beide Seiten haben inzwischen Fähigkeiten, die die andere nicht kennt. Und die Werkzeugkette entscheidet meist mehr als das Binary: Wer HCP Terraform, Sentinel oder Terraform Enterprise nutzt, tauscht nicht ein Kommandozeilenwerkzeug, sondern ein Betriebsmodell.

Miniatur-Szene: zwei Plattformen nebeneinander mit unterschiedlichen Cloud-Bausteinen, dazwischen eine Waage

Fünf Prüfpunkte für die Werkzeugentscheidung

  1. 01 Nutzungsfall: interne Infrastruktur oder Angebot an Dritte
  2. 02 Funktionsstand bei State, Registry und Werkzeugen für Tests
  3. 03 Werkzeugkette: CI, Richtlinien, Kostenschätzung, Drift
  4. 04 Wechseltest: ein echter Stack mit leerem Plan
  5. 05 Rückweg: gesicherter State, gesperrte Exklusivfunktionen
Was du mitnimmst

So zerlegst du die Entscheidung

Die Frage besteht aus fünf Teilen, und vier davon beantwortest du an einem Tag. Nur die Werkzeugkette braucht echte Projektzeit.

Nutzungsfall vor Lizenztext

Kläre zuerst, was ihr mit dem Werkzeug macht. Interne Infrastruktur bauen, auch produktiv und auch für viele Mandanten im eigenen Konzern, ist von der Lizenz gedeckt. Kritisch wird es erst, wenn ihr Terraform-Läufe als Dienstleistung an Dritte verkauft. Diese Unterscheidung erspart den meisten Häusern die gesamte übrige Diskussion.

Funktionsstand statt Lagerdenken

Vergleiche an den drei Stellen, die im Betrieb weh tun: Wie kommen Geheimnisse aus dem State heraus, wie kommen Provider und Module in abgeschottete Netze hinein, und wie testet ihr Module ohne echte Ressourcen. An diesen Punkten unterscheiden sich die Projekte messbar, nicht an Absichtserklärungen.

Der Wechsel ist billig, der Rückweg nicht

Solange nur das Binary getauscht wird, ist der Weg in beide Richtungen offen. Sobald werkzeugexklusive Funktionen im Code stehen, ist er einseitig. Behandle diese Funktionen deshalb als bewusste Freigabe mit Datum und Verantwortlichem, nicht als Detail, das eine Entwicklerin im Feierabend einbaut.

Die Werkzeugkette ist die eigentliche Frage

CI-Pipelines, Richtlinienprüfung, Kostenschätzung, Drift-Erkennung und Freigabeprozesse hängen am Werkzeug. Kommerzielle Plattformen unterstützen inzwischen meist beide Varianten, eure eigenen Skripte womöglich nicht. Nimm dir einen halben Tag und geh die Kette einmal Glied für Glied durch, bevor irgendjemand ein Datum nennt.

Provider bleiben, wo sie sind

Die Provider für AWS, Azure, Google Cloud und Kubernetes stehen üblicherweise unter MPL 2.0 oder Apache 2.0 und laufen in beiden Werkzeugen. Was sich ändert, ist der Bezugsweg über die jeweilige Registry. Mit einem eigenen Spiegel verliert dieser Unterschied den größten Teil seiner Bedeutung.

Tutorial

Vom Lizenzcheck bis zum ersten produktiven Stack

Wer Terraform nur für die eigene Infrastruktur einsetzt, dem verbietet die Lizenz nichts, damit ist die juristische Frage in den meisten Häusern nach zehn Minuten erledigt. Danach entscheidet die Werkzeugkette, denn der Wechsel selbst kostet einen Nachmittag und teuer wird nur der Rückweg. In dieser Reihenfolge geht es weiter: Lizenzcheck, Funktionsvergleich, Testlauf an einem echten Stack, verlässlicher Bezug von Providern und Modulen und zum Schluss die Absicherung in der Pipeline.

01

Schritt 1: Prüfen, ob euch die Lizenz überhaupt betrifft

Bevor jemand ein Binary austauscht, gehört die juristische Frage vom Tisch. In den meisten Häusern ist sie nach zehn Minuten beantwortet.

Die Business Source License 1.1 ist keine Open-Source-Lizenz, aber auch keine übliche proprietäre Lizenz. Der Quelltext bleibt einsehbar, die Nutzung ist erlaubt, und jede Version wechselt zum festgelegten Change Date automatisch auf die Mozilla Public License 2.0. Entscheidend ist der Additional Use Grant: Untersagt ist der produktive Einsatz nur dann, wenn ihr das Werkzeug Dritten in einer Form bereitstellt, die mit den Produkten des Rechteinhabers konkurriert. Für die Frage, ob euer Haus betroffen ist, brauchst du also keinen Blick in den Code, sondern in euer Geschäftsmodell.

Wen die Business Source License trifft

NutzungsfallBetroffen?Worauf du achtest
Eigene Infrastruktur bauen und betreiben, auch produktivNeinDer Zusatz erlaubt produktive Eigennutzung ausdrücklich, unabhängig von der Größe
Systemhaus baut Infrastruktur im Kundenprojekt, Code bleibt beim KundenIn aller Regel neinKritisch wird es erst, wenn ihr eine eigene Terraform-Plattform als Produkt verkauft
Eigenes SaaS-Angebot, das Terraform-Läufe für fremde Kunden ausführtSehr wahrscheinlich jaGenau auf diesen Fall zielt die Einschränkung, hier gehört die Rechtsabteilung an den Tisch
Provider oder Module entwickeln und veröffentlichenNeinProvider stehen fast immer unter MPL 2.0 oder Apache 2.0, nicht unter der BUSL
Binaries gebündelt an Dritte weitergeben, etwa in einer AppliancePrüfen lassenDie Grenze verläuft am Begriff des konkurrierenden Angebots und ist hier nicht offensichtlich

Halte das Ergebnis schriftlich fest, mit Datum und geprüfter Lizenzfassung. Ohne dieses Dokument beginnt die Diskussion beim nächsten Audit und beim nächsten Lieferantenfragebogen von vorn. Steht ohnehin eine grundsätzliche Werkzeugwahl an, gehört sie in denselben Vorgang wie der Vergleich der Werkzeuge für Infrastructure as Code.

02

Schritt 2: Funktionsstände nebeneinanderlegen

Seit dem Fork gehen beide Projekte eigene Wege. Der Vergleich lohnt sich an den Stellen, die im Betrieb wirklich Ärger machen.

Das bekannteste Beispiel ist der State. Er enthält Zugangsdaten im Klartext, sobald eine Ressource welche erzeugt, etwa ein Datenbankpasswort oder einen Zugriffsschlüssel. Ein verschlüsselter Bucket schützt nur gegen den Verlust des Buckets, nicht gegen jeden im Haus, der Leserechte darauf hat. OpenTofu löst das mit clientseitiger Verschlüsselung des State. Terraform geht den anderen Weg und sorgt mit ephemeren Werten und Write-only-Argumenten dafür, dass sensible Werte gar nicht erst im State landen. Beide Ansätze funktionieren, verlangen aber unterschiedliche Umbauten am Code.

backend.tf: clientseitige State-Verschlüsselung in OpenTofu
terraform {
  encryption {
    key_provider "pbkdf2" "passphrase" {
      passphrase = var.state_passphrase
    }

    method "aes_gcm" "standard" {
      keys = key_provider.pbkdf2.passphrase
    }

    state {
      method   = method.aes_gcm.standard
      enforced = true
    }
  }
}

enforced = true sorgt dafür, dass ein unverschlüsselter Stand gar nicht erst geschrieben wird. Ohne dieses Flag akzeptiert OpenTofu weiterhin Klartext, was für die Umstellungsphase gedacht ist und danach gerne vergessen wird. In der Produktion nimmst du statt pbkdf2 einen Schlüssel aus AWS KMS oder Azure Key Vault, damit die Passphrase nicht im Repository landet.

Wo sich die Projekte messbar unterscheiden

  • OpenTofu verschlüsselt den State auf Client-Seite, konfiguriert im encryption-Block. Damit ist auch ein versehentlich kopierter State wertlos.
  • OpenTofu kann Provider und Module aus OCI-Registries beziehen. In abgeschotteten Netzen ist das der praktisch wichtigste Unterschied, weil dort eine OCI-Registry ohnehin schon steht.
  • OpenTofu erlaubt for_each auf Provider-Konfigurationen, etwa für viele Regionen oder viele Konten in einem Lauf.
  • Terraform setzt auf ephemere Ressourcen und Write-only-Argumente, damit Geheimnisse den State nie erreichen. Das ist der sauberere, aber invasivere Weg.
  • Rund um Terraform liegt das größere kommerzielle Ökosystem, von Richtlinienprüfung mit Sentinel bis zu Support mit vertraglich zugesagten Reaktionszeiten.

Wichtig ist die Reihenfolge: Erst prüfen, welche dieser Funktionen ihr wirklich braucht, dann entscheiden. Ein Team, das seine Geheimnisse ohnehin über einen externen Tresor bezieht und niemals im State ablegt, gewinnt durch die State-Verschlüsselung wenig. Ein Team, das für eine Behörde in einem Netz ohne Internetzugang arbeitet, gewinnt durch den OCI-Bezug sehr viel. Die Frage nach dem größeren Ökosystem beantwortet ihr an eurer Pipeline, nicht an einer Featureliste.

03

Schritt 3: Den Wechsel an einem echten Stack testen

Der Wechsel ist kein Migrationsprojekt, sondern ein Testlauf. Nimm dafür einen mittelgroßen produktiven Stack und nicht das Beispiel aus der Dokumentation.

Wechsel an einem Stack durchspielen
# 1. State sichern, bevor irgendetwas anderes passiert
terraform state pull > state-$(date +%F).json
sha256sum state-*.json | tee state-pruefsummen.txt

# 2. OpenTofu installieren, Installationsskript vorher lesen
curl -fsSL https://get.opentofu.org/install-opentofu.sh -o install-opentofu.sh
less install-opentofu.sh
chmod +x install-opentofu.sh
./install-opentofu.sh --install-method deb

# 3. Initialisieren und den Ist-Zustand vergleichen
tofu init -upgrade
tofu plan -detailed-exitcode -out=tofu.plan
echo "Exitcode: $?"

Der interessante Wert ist der Exitcode: 0 bedeutet keine Abweichung, 2 bedeutet geplante Änderungen, 1 bedeutet Fehler. Eine 0 ist dein Abnahmekriterium. Eine 2 heißt nicht automatisch, dass etwas kaputt ist, sondern meist, dass unterschiedliche Provider-Versionen gezogen wurden. Vergleiche dann zuerst die .terraform.lock.hcl.

Plane den Testlauf so, dass ein apply zunächst gar nicht vorgesehen ist. Erst wenn mehrere Stacks nacheinander einen leeren Plan liefern, nimmst du den ersten unkritischen Stack produktiv unter OpenTofu. Alles andere bleibt vorerst bei Terraform. Ein Parallelbetrieb über einige Wochen ist ausdrücklich möglich, weil beide Werkzeuge dasselbe State-Format lesen, und er ist deutlich billiger als ein Stichtag, an dem alles gleichzeitig kippt.

04

Schritt 4: Provider und Module verlässlich beziehen

Die Registry ist der Teil, den die meisten unterschätzen. Im Alltag ist sie unsichtbar, im Störfall ist sie das Erste, was fehlt.

Terraform und OpenTofu nutzen getrennte Registries. Die Provider selbst sind davon meist unberührt, sie stehen üblicherweise unter MPL 2.0 oder Apache 2.0 und laufen in beiden Werkzeugen. Was sich ändert, ist der Bezugsweg. In regulierten Umgebungen solltest du den ohnehin nicht dem Internet überlassen, sondern die Artefakte spiegeln, so wie es auch Cluster ohne Internetzugang tun. Ein lokaler Spiegel macht Läufe reproduzierbar, überlebt Ausfälle der öffentlichen Registry und nimmt der ganzen Registry-Frage einen Großteil ihrer Brisanz.

Provider einmal spiegeln und danach offline arbeiten
# Alle im Projekt referenzierten Provider in ein Verzeichnis holen
tofu providers mirror /srv/tofu/provider-mirror

# Ergebnis pruefen: je Provider ein Verzeichnis mit Versionen und Pruefsummen
find /srv/tofu/provider-mirror -maxdepth 4 -type d | head -n 20

# Welche Provider haengen ueberhaupt am Projekt?
tofu providers

Der Spiegel gehört auf ein Volume, das gesichert wird, nicht in ein Home-Verzeichnis auf einem Build-Knoten. Bei Terraform heißt derselbe Befehl terraform providers mirror und legt dieselbe Verzeichnisstruktur an.

/etc/tofu/tofurc: Bezug auf den Spiegel festlegen
provider_installation {
  filesystem_mirror {
    path    = "/srv/tofu/provider-mirror"
    include = ["registry.opentofu.org/*/*"]
  }

  direct {
    exclude = ["registry.opentofu.org/*/*"]
  }
}

Damit greift kein Lauf mehr ins Internet, solange der gesuchte Provider im Spiegel liegt. Für Terraform gilt dieselbe Syntax in ~/.terraformrc, nur mit registry.terraform.io als Host. Ein fehlender Provider fällt dann sofort beim init auf und nicht erst nachts in der Pipeline.

05

Schritt 5: Die Entscheidung revisionsfest machen

Was in der Pipeline nicht erzwungen wird, gilt nach drei Monaten nicht mehr. Diese Punkte gehören deshalb in die Automatisierung und nicht in ein Protokoll.

Vor dem produktiven Umschalten

  • Die Version des Werkzeugs in der Pipeline auf eine exakte Nummer festlegen.Ein unbemerktes Update kann ein neueres State-Format schreiben. Der Rückweg zur alten Version ist danach versperrt, und zwar für alle Beteiligten gleichzeitig.
  • Den State vor dem ersten Lauf sichern und die Prüfsumme getrennt ablegen.Der State ist die einzige Verbindung zwischen Code und realer Infrastruktur. Ohne ihn beginnt der Wiederaufbau bei null, mit von Hand importierten Ressourcen.
  • Werkzeugexklusive Funktionen bewusst freigeben oder sperren.State-Verschlüsselung und Provider-Iteration sind nützlich, schließen aber den Rückweg. Diese Entscheidung sollte jemand treffen und nicht jemand versehentlich auslösen.
  • Die Werkzeugkette einzeln durchgehen: CI, Richtlinienprüfung, Kostenschätzung, Drift-Erkennung.Das Binary ist in einer Stunde getauscht, ein gewachsenes Regelwerk nicht. Wer das erst nach dem Umschalten merkt, betreibt eine Weile ganz ohne Leitplanken.
  • Das Ergebnis der Lizenzprüfung mit Datum und Lizenzfassung dokumentieren.Die Frage kommt beim nächsten Audit und beim nächsten Lieferantenfragebogen wieder. Ohne Dokument beantwortet sie jedes Mal jemand anderes, und irgendwann falsch.
.gitlab-ci.yml: Werkzeug und Ergebnis festnageln
variables:
  TOFU_VERSION: "1.9.0"   # exakte Version, niemals latest

plan:
  image: ghcr.io/opentofu/opentofu:$TOFU_VERSION
  script:
    - tofu init -input=false -lockfile=readonly
    - tofu plan -input=false -detailed-exitcode -out=tofu.plan || rc=$?
    - test "${rc:-0}" -ne 1   # 1 waere ein echter Fehler, 2 sind Aenderungen
  artifacts:
    paths: [tofu.plan]
    expire_in: 1 week

-lockfile=readonly verhindert, dass ein Lauf die Provider-Versionen still nachzieht. Achte auf die Auswertung des Exitcodes: GitLab wertet jeden Wert ungleich null als Fehler, und -detailed-exitcode liefert bei geplanten Änderungen eine 2. Ohne die Abfrage oben ist jeder Plan mit Änderungen ein roter Job.

Gut zu wissen

Häufige Fragen zu Terraform und OpenTofu

Noch etwas offen? Wir sind ohne Warteschleife für dich da.

Frag uns direkt
Dürfen wir Terraform überhaupt noch einsetzen?
Ja, wenn ihr damit eure eigene Infrastruktur baut. Die Business Source License erlaubt den produktiven Einsatz ausdrücklich und schränkt ihn nur dort ein, wo das Werkzeug Dritten als konkurrierendes gehostetes oder eingebettetes Angebot bereitgestellt wird. Ein Unternehmen, das Terraform für seine eigenen Konten und Umgebungen nutzt, ist davon nicht betroffen, auch nicht bei mehreren Tochtergesellschaften. Wer dagegen eine Plattform betreibt, auf der fremde Kunden Terraform-Läufe ausführen, sollte die Formulierung juristisch prüfen lassen. Dokumentiert das Ergebnis mit Datum, dann steht die Antwort beim nächsten Audit bereit.
Wie aufwendig ist der Wechsel zu OpenTofu wirklich?
Bei sauber strukturiertem Code ist der reine Wechsel eine Sache von Stunden: Binary installieren, initialisieren, planen, den leeren Plan als Nachweis nehmen. Zeit kostet alles andere. Die CI-Pipelines müssen ein neues Image ziehen, Richtlinien- und Kostenwerkzeuge brauchen Anpassungen, Dokumentation und Runbooks nennen überall den alten Befehl, und Entwicklungsumgebungen auf den Arbeitsplätzen wollen ebenfalls umgestellt sein. Rechne mit einem Nachmittag pro Stack und zusätzlich mit ein bis zwei Wochen für die Werkzeugkette, wenn ihr eine gewachsene Automatisierung habt.
Läuft unser bestehender Terraform-Code unverändert unter OpenTofu?
In den allermeisten Fällen ja. OpenTofu ist aus dem letzten frei lizenzierten Terraform-Stand entstanden, liest dasselbe State-Format und versteht dieselbe Sprache. Abweichungen treten auf, wenn euer Code Funktionen nutzt, die erst nach dem Fork in Terraform hinzugekommen sind, etwa ephemere Ressourcen oder Write-only-Argumente. Der zuverlässigste Test ist ein Plan mit -detailed-exitcode auf einem echten Stack: Liefert er eine 0, sieht OpenTofu genau denselben Zustand. Prüfe zusätzlich die Provider-Versionen in der Lock-Datei, weil dort die meisten unerwarteten Abweichungen herkommen.
Was ändert sich durch die Übernahme von HashiCorp durch IBM?
Kurzfristig an der Lizenz nichts. Die Business Source License gilt weiter, der Additional Use Grant ebenso. Was sich verändern kann, sind Preismodelle, Produktbündelung und die Frage, wie stark das kommerzielle Angebot mit dem übrigen Portfolio verschmilzt. Für die Werkzeugentscheidung ist das ein Argument unter mehreren, nicht das entscheidende. Wichtiger ist die nüchterne Frage, ob euer Betrieb von einer einzelnen Produktentscheidung eines Herstellers abhängt. Wer den State sichert, Provider spiegelt und keine exklusiven Funktionen einbaut, bleibt in beide Richtungen handlungsfähig.
Sollen wir Terraform und OpenTofu parallel betreiben?
Für eine Übergangszeit ja, dauerhaft nein. In der Übergangszeit ist der Parallelbetrieb sogar der sicherste Weg, weil beide Werkzeuge dasselbe State-Format lesen und ihr Stack für Stack umstellen könnt. Dauerhaft zahlt ihr dafür mit doppelten Images, doppelten Schulungen und der ständigen Frage, welche Sprachfunktionen im gemeinsamen Modulcode erlaubt sind. Sinnvoll bleibt allenfalls eine kleine, unkritische Umgebung, die dauerhaft unter dem jeweils anderen Werkzeug läuft und damit den Rückweg belegt.

Zuletzt geprüft am 26. Juli 2026.

Das sagen Teilnehmer

Echte Stimmen aus unseren IT-Kursen

Der Kurs hat sein Ziel erreicht. Der Trainer konnte die Inhalte gut rüberbringen und der Praxisanteil und die Übungsumgebung war sehr gut.
Rückmeldung aus dem Kurs „Terraform mit Azure – Der kompakte Praxiskurs für Ihren Cloud-Erfolg“
Sehr intensiver Lehrgang, hat mich für meine Arbeit ein gutes Stück voran gebracht.
Rückmeldung aus dem Kurs „Monitoring mit Prometheus und Grafana - Grundkurs“
Persönlich für dich da

Deine Ansprechpartner

Du bist dir nicht sicher, welcher Kurs oder welches Level zu dir passt? Wir beraten dich persönlich und kostenlos.

Yves Hoppe

Yves Hoppe

Weiterbildung & Beratung

Hilft dir, aus dem Cloud-Programm den passenden Kurs oder Lernpfad zu finden.

Norbert Jansen

Norbert Jansen

Beratung & Inhouse

Plant mit dir Inhouse-Trainings, die exakt auf eure Systemlandschaft und Distributionen zugeschnitten sind.

Nächster Schritt

Werkzeug entschieden, jetzt das Team dahinter

Wenn die Richtung feststeht, bringen wir dein Team auf den Stand. cmt bietet den OpenTofu Grundkurs ebenso wie die Terraform-Reihe für AWS vom Einstieg bis zum Aufbaukurs und einen eigenen Kurs für Terraform mit Azure. Bist du noch unentschieden, sprich uns an: Wir schauen uns eure Werkzeugkette an und sagen dir, wo der Wechsel wirklich Arbeit macht.