CloudFormation versus Terraform

Terraform is superieur aan CloudFormation in elk scenario, behalve wanneer u absoluut geavanceerde functies van AWS moet gebruiken. Dit is waarom.

Leercurve:

Ik denk dat de meeste mensen nieuwe technologieën leren, door zelfstudies te volgen of naar voorbeelden te kijken. Dit is vrij eenvoudig te doen met de meeste programmeertalen, althans voor een instapniveau.
Niet met CloudFormation. Het is JSON (of YAML) geformatteerd. Het is ontworpen om te worden geconsumeerd en geproduceerd door computers - niet door mensen. Probeer het zelf, hieronder is een voorbeeld van een codefragment vereist om een ​​EC2-instantie (in feite een VM) te laten draaien:

{
  "AWSTemplateFormatVersion": "09-09-2010",
....
150 lijnen bla bla bla ...
....
  },

  "Bronnen": {
    "EC2Instance": {
      "Type": "AWS :: EC2 :: Instance",
      "Eigendommen" : {
        "UserData": {"Fn :: Base64": {"Fn :: Join": ["", ["IPAddress =", {"Ref": "IPAddress"}]]}},
        "InstanceType": {"Ref": "InstanceType"},
        "SecurityGroups": [{"Ref": "InstanceSecurityGroup"}],
        "KeyName": {"Ref": "KeyName"},
        "ImageId": {"Fn :: FindInMap": ["AWSRegionArch2AMI", {"Ref": "AWS :: Region"},
                          {"Fn :: FindInMap": ["AWSInstanceType2Arch", {"Ref": "InstanceType"}, "Arch"]}]}
      }
    },

    "InstanceSecurityGroup": {
      "Type": "AWS :: EC2 :: SecurityGroup",
      "Eigendommen" : {
        "GroupDescription": "SSH-toegang inschakelen",
        "SecurityGroupIngress":
          [{"IpProtocol": "tcp", "FromPort": "22", "ToPort": "22", "CidrIp": {"Ref": "SSHLocation"}}]]
      }
    },

    "IP adres" : {
      "Type": "AWS :: EC2 :: EIP"
    },

    "IPAssoc": {
      "Type": "AWS :: EC2 :: EIPAssociation",
      "Eigendommen" : {
        "InstanceId": {"Ref": "EC2Instance"},
        "EIP": {"Ref": "IPAddress"}
      }
    }
  },
  "Uitgangen": {
    "InstanceId": {
      "Description": "InstanceId van het nieuw gecreëerde EC2-exemplaar",
      "Value": {"Ref": "EC2Instance"}
    },
    "InstanceIPAddress": {
      "Description": "IP-adres van het nieuw gecreëerde EC2-exemplaar",
      "Value": {"Ref": "IPAddress"}
    }
  }
}

Naar. 210 coderegels om een ​​VM met openbare IP te krijgen die wordt beschermd door Security Group. 210. 210! Bij elke sjabloon is er een enorme hoeveelheid boilerplate-code, dat is eigenlijk ruis (hierover later meer).
Als dat niet genoeg is om je in dit stadium af te schrikken, bekijk dan de officiële documentatie. Het is nu verschoven naar het gebruik van YAML, maar als je naar voorbeeldfragmenten wilt kijken, blijkt dat ze allemaal in JSON zitten. Hetzelfde geldt voor Google-resultaten.
BTW. wanneer je verschillende voorbeeldfragmenten per regio hebt, kun je zeggen dat er iets niet klopt

Ronde # 1: CF: 0 TF: 1

Code schrijven

Vrijwel dezelfde argumenten als hierboven zijn van toepassing op het schrijven van de code zelf. Kijk voor een snel voorbeeld naar exact dezelfde bronnen als hierboven, maar beschreven in Terraform:

resource "aws_instance" "web" {
  ami = "12345-6789-10"
  instance_type = "t2.micro"

  tags {
    Name = "Sweet"
  }
}
data "aws_eip" "pip" {
  public_ip = "1.1.1.1"
}

resource "aws_eip_association" "pip" {
  instance_id = "$ {aws_instance.web.id}"
  allocatie_id = "$ {data.aws_eip.pip.id}"
}
resource "aws_security_group" "allow_all" {
  name = "allow_ssh"
  description = "Laat ssh overal toe"

  ingress {
    from_port = 0
    to_port = 22
    protocol = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
}
resource "aws_network_interface_sg_attachment" "sg_attachment" {
  security_group_id = "$ {aws_security_group.allow_all.id}"
  network_interface_id = "$ {aws_instance.web.primary_network_interface_id}"
}

Verschil is schokkend, nietwaar? Merk op hoe gemakkelijk het is om naar andere bronnen te verwijzen op basis van hun ID's. Met een snelle blik kunt u zien wat er gebeurt en fundamentele wijzigingen aanbrengen in de infrastructuur. Dat brengt ons mooi op een ander punt

Ronde # 2 CF: 0 TF: 1

Code valideren

CF staat alleen syntaxiscontrole toe. Dus in het beste geval zal het je vertellen dat je hier en daar een haakje hebt gemist. Voordat u CloudFormation-sjabloon probeert toe te passen, weet u niet of elke variabele die u heeft gebruikt, kan worden opgelost, maar wat het grootste nadeel is, is dat u niet weet wat er gaat gebeuren.
Terraform daarentegen valideert .tf-bestanden en controleert niet alleen de syntaxis, maar ook of alle dependecines goed oplossen, en het geeft je een plan! Ja, met Terraform krijg je echt te zien wat je gaat maken / wijzigen / vernietigen voordat je je code toepast!

Een uitvoeringsplan is gegenereerd en wordt hieronder weergegeven.
Bronacties worden aangegeven met de volgende symbolen:
  + maken
Terraform zal de volgende acties uitvoeren:
+ azurerm_resource_group.test_tf101
      id: 
      locatie: "ukwest"
      naam: "test_tf101"
      tags.%: 
+ azurerm_subnet.sub1
      id: 
      address_prefix: "172.16.0.8/29"
      ip_configurations. #: 
      naam: "sub-1"
      network_security_group_id: 
      resource_group_name: "test_tf101"
      route_table_id: 
      virtual_network_name: "test_vnet"
Plan: 2 toevoegen, 0 wijzigen, 0 vernietigen.
-------------------------------------------------- ------------------

Ronde # 3 CF: 0 TF: 1

Externe status

Met Terraform kunt u eenvoudig gegevens importeren van externe bronnen, bijvoorbeeld andere omgevingen die in een andere status worden beheerd. Hiermee kunt u eenvoudig middelen en verantwoordelijkheden scheiden. Verklaar eenvoudig de bron van externe informatie en gebruik wat er wordt blootgesteld.
CloudFormation heeft het idee van Cross-Stack Referenties, maar zelfs het doornemen van de documentatie is lastig, en een voorbeeld op AWS om VPC peering in te stellen is 71 regels, vergeleken met 17 in Terraform.

Ronde # 4 CF: 0 TF: 1

functies

Controleer het onderstaande fragment.

resource "aws_instance" "web" {
  # Maak een instantie voor elke hostnaam
  count = "$ {length (var.hostnames)}"

  # Geef aan elke instantie het bijbehorende template_file
  user_data = "$ {data.template.web_init. *. rendered [count.index]}"
}

Ja. Terraform heeft nogal wat ingebouwde functies waarmee u logica in uw code kunt plaatsen, zodat u beter kunt bouwen met minder code of verschillende structuren kunt laten bouwen met dezelfde code, maar met verschillende variabelen afhankelijk van de behoeften.

Ronde # 5 CF: 0 TF: 1

modules

U kunt bepaalde bronnen die u altijd in combinatie gebruikt, groeperen en modules maken, waardoor het nog eenvoudiger wordt om bepaalde soorten bronnen aan te geven. Je zou het zo kunnen comprimeren dat het declareren van een VM slechts 4 regels code is! Wat meer is, met behulp van variabele "telling" kunt u er zoveel hebben als u wilt, eenvoudig door een nummer te wijzigen.

variabele "count" {
  standaard = 2
}

resource "aws_instance" "web" {
  # ...

  count = "$ {var.count}"

  # Tag de instantie met een teller die begint bij 1, dat wil zeggen. web-001
  tags {
    Name = "$ {format (" web-% 03d ", count.index + 1)}"
  }
}

Ronde # 6 CF: 0 TF: 1

Teamwerk

Omdat HCL van Terraform net als elke andere programmeertaal is, is het Git-vriendelijk op een manier die verzoeken goed markeert om wijzigingen te markeren, dus het is comfortabel om beoordelingen te doen en samen te werken aan een stukje code. Probeer hetzelfde met JSON, dat uiteindelijk een gegevensstructuur is. De helft van de diffs is alleen boilerplate-geluid, en nog wat.

Ronde # 7 CF: 0 TF: 1

providers

Grotendeels onderschatte kracht van Terraform is de mogelijkheid om elk aspect van uw infrastructuur te besturen met dezelfde tool. Je hebt een lijst met meer dan 70 providers die je kunt gebruiken, variërend van AWS, via Azure tot Gitlab, Fastly, Chef, Docker, noem maar op. En het maakt allemaal gebruik van dezelfde HCL die je een keer moet leren. Verbazingwekkend!

Ronde # 8 CF: 0 TF: 1

Samenvatting

Na 8 rondes is het

CloudFormation: 0 vs Terraform: 8.

Zelfs na het toevoegen van een extra punt, zelfs twee bij CloudFormation omdat hij dichter bij het AWS-aanbod is eindresultaat is CF 2 TF 8, wat betekent dat Terraform zijn tegenstander absoluut heeft verpletterd!
Ik ben er vrij zeker van dat hetzelfde geldt voor Azure ARM-sjablonen versus Terraform, dus daar is het, twee vergelijkingen in één. Dat noem ik efficiëntie.

ontkenning
Dit bericht staat vol met snelkoppelingen en waarschijnlijk ook fouten en misvattingen, die ik graag corrigeer wanneer ik erop wordt gewezen. Ik wil graag een discussie op gang brengen, dus misschien is hier of daar een aas verborgen. Terraform FTW.