Dlaczego Infrastructure as Code to przyszłość

Wyobraź sobie sytuację: musisz utworzyć identyczne środowisko testowe, staging i produkcyjne. Tradycyjnie oznacza to godziny klikania w panelach administracyjnych, ręczne tworzenie instancji EC2, konfigurowanie security groups, load balancerów… A co jeśli pomylisz się w jednym kroku? Co jeśli za miesiąc musisz powtórzyć ten proces?

Infrastructure as Code (IaC) rozwiązuje te problemy poprzez opisanie całej infrastruktury w plikach tekstowych, które można wersjonować, testować i wielokrotnie używać. Terraform od HashiCorp to obecnie jedno z najlepszych narzędzi IaC na rynku.

Czym jest Terraform i Infrastructure as Code

Terraform to narzędzie open-source stworzone przez HashiCorp w 2014 roku, które implementuje koncepcję Infrastructure as Code. Najważniejsze cechy Terraform:

**Deklaratywność:** Opisujesz JAK ma wyglądać Twoja infrastruktura, a nie KROKI jej tworzenia. Terraform sam ustala co i w jakiej kolejności utworzyć.

**Multi-cloud:** Działa z AWS, Azure, Google Cloud, ale też z setkami innych providerów – od DNSów po monitoring.

**State management:** Terraform pamięta aktualny stan infrastruktury i potrafi wykryć różnice między kodem a rzeczywistością.

Instalacja i pierwsze kroki z Terraform

### Instalacja Terraform

Terraform to pojedynczy plik wykonywalny. Na macOS najprościej przez Homebrew:

# macOS
brew install terraform

# Linux (Ubuntu/Debian)
wget https://releases.hashicorp.com/terraform/0.11.1/terraform_0.11.1_linux_amd64.zip
unzip terraform_0.11.1_linux_amd64.zip
sudo mv terraform /usr/local/bin/

Sprawdź instalację:

terraform version
# Terraform v0.11.1

### Konfiguracja AWS

Terraform potrzebuje uprawnień do tworzenia zasobów w AWS. Utwórz użytkownika IAM z odpowiednimi uprawnieniami:

# Ustaw credentials przez AWS CLI
aws configure

# Lub przez zmienne środowiskowe
export AWS_ACCESS_KEY_ID="your-access-key"
export AWS_SECRET_ACCESS_KEY="your-secret-key"
export AWS_DEFAULT_REGION="us-west-2"

Pierwszy projekt Terraform – EC2 Instance

Stwórzmy pierwszy projekt Terraform, który utworzy prostą instancję EC2 w AWS.

### Struktura projektu

mkdir terraform-first-project
cd terraform-first-project
touch main.tf

### Plik main.tf

# Provider configuration
provider "aws" {
  region = "us-west-2"
}

# Data source to get latest Amazon Linux AMI
data "aws_ami" "amazon_linux" {
  most_recent = true
  owners      = ["amazon"]

  filter {
    name   = "name"
    values = ["amzn-ami-hvm-*-x86_64-gp2"]
  }
}

# Security group for our instance
resource "aws_security_group" "web_sg" {
  name_prefix = "terraform-example-"

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  ingress {
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }

  tags {
    Name = "terraform-example-sg"
  }
}

# EC2 Instance
resource "aws_instance" "web_server" {
  ami           = "${data.aws_ami.amazon_linux.id}"
  instance_type = "t2.micro"
  
  vpc_security_group_ids = ["${aws_security_group.web_sg.id}"]
  
  user_data = <<-EOF
              #!/bin/bash
              yum update -y
              yum install -y httpd
              systemctl start httpd
              systemctl enable httpd
              echo "
Hello from Terraform!
" > /var/www/html/index.html
              EOF

  tags {
    Name = "terraform-example-server"
  }
}

# Output the public IP
output "public_ip" {
  value = "${aws_instance.web_server.public_ip}"
}

### Podstawowe komendy Terraform

# 1. Inicjalizacja - pobiera potrzebne providery
terraform init

# 2. Plan - pokazuje co będzie utworzone/zmienione
terraform plan

# 3. Apply - wykonuje zmiany
terraform apply

# 4. Sprawdzenie stanu
terraform show

# 5. Usunięcie infrastruktury
terraform destroy

Terraform workflow krok po kroku

### 1. Terraform Init

$ terraform init

Initializing provider plugins...
- Checking for available provider plugins on https://releases.hashicorp.com...
- Downloading plugin for provider "aws" (1.6.0)...

Terraform has been successfully initialized!

Ta komenda:
– Pobiera pluginy providerów (w naszym przypadku AWS)
– Tworzy ukryty folder .terraform
– Przygotowuje backend do przechowywania state

### 2. Terraform Plan

$ terraform plan

Refreshing Terraform state in-memory prior to plan...

------------------------------------------------------------------------

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

Terraform will perform the following actions:

+ aws_instance.web_server
    ami:                         "ami-0def3275"
    instance_type:               "t2.micro"
    vpc_security_group_ids.#:    "1"
    
+ aws_security_group.web_sg
    name_prefix:                 "terraform-example-"
    ingress.#:                   "2"

Plan: 2 to add, 0 to change, 0 to destroy.

### 3. Terraform Apply

$ terraform apply

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

aws_security_group.web_sg: Creating...
aws_security_group.web_sg: Creation complete after 2s (ID: sg-12345678)
aws_instance.web_server: Creating...
aws_instance.web_server: Still creating... (10s elapsed)
aws_instance.web_server: Creation complete after 31s (ID: i-87654321)

Apply complete! Resources: 2 added, 0 changed, 0 destroyed.

Outputs:

public_ip = 52.12.34.56

Po kilku minutach możesz otworzyć http://52.12.34.56 i zobaczyć stronę „Hello from Terraform!”

State management – serce Terraform

Terraform przechowuje informacje o utworzonej infrastrukturze w pliku terraform.tfstate. Ten plik zawiera:

– Jakie zasoby zostały utworzone
– Ich aktualne identyfikatory (ID)
– Powiązania między zasobami
– Metadane i właściwości

Sprawdź zawartość state:

# Wyświetl stan w czytelnej formie
terraform show

# Lista zasobów w state
terraform state list

# Szczegóły konkretnego zasobu
terraform state show aws_instance.web_server

Organizacja kodu Terraform

W większych projektach warto podzielić kod na pliki:

terraform-project/
├── main.tf          # Główne zasoby
├── variables.tf     # Definicje zmiennych
├── outputs.tf       # Definicje outputów
├── provider.tf      # Konfiguracja providerów
└── terraform.tfvars # Wartości zmiennych

### Przykład z zmiennymi

**variables.tf:**

variable "region" {
  description = "AWS region"
  default     = "us-west-2"
}

variable "instance_type" {
  description = "EC2 instance type"
  default     = "t2.micro"
}

variable "server_name" {
  description = "Name tag for the server"
  type        = "string"
}

**terraform.tfvars:**

region = "us-east-1"
instance_type = "t2.small"
server_name = "production-web-server"

**main.tf (z użyciem zmiennych):**

provider "aws" {
  region = "${var.region}"
}

resource "aws_instance" "web_server" {
  ami           = "${data.aws_ami.amazon_linux.id}"
  instance_type = "${var.instance_type}"
  
  tags {
    Name = "${var.server_name}"
  }
}

Najlepsze praktyki Terraform

### 1. Używaj remote state

Dla zespołów krytyczne jest przechowywanie state w centralnym miejscu:

terraform {
  backend "s3" {
    bucket = "my-terraform-state-bucket"
    key    = "prod/terraform.tfstate"
    region = "us-west-2"
  }
}

### 2. Organizuj zasoby w modules

modules/
├── vpc/
│   ├── main.tf
│   ├── variables.tf
│   └── outputs.tf
├── web-server/
│   ├── main.tf
│   ├── variables.tf
│   └── outputs.tf
└── database/
    ├── main.tf
    ├── variables.tf
    └── outputs.tf

### 3. Zawsze planuj przed apply

### 4. Taguj wszystkie zasoby

resource "aws_instance" "web_server" {
  ami           = "${data.aws_ami.amazon_linux.id}"
  instance_type = "t2.micro"
  
  tags {
    Name        = "web-server"
    Environment = "production"
    Project     = "website"
    Owner       = "devops-team"
    ManagedBy   = "terraform"
  }
}

Rozwiązywanie problemów

### Typowe błędy początkujących

### Przydatne komendy debugowania

# Sprawdź składnię
terraform validate

# Sformatuj kod
terraform fmt

# Odśwież state bez zmian
terraform refresh

# Wyświetl graf zależności
terraform graph | dot -Tpng > graph.png

Przydatne zasoby:

• Oficjalna dokumentacja Terraform
• AWS Provider dla Terraform
• Terraform na GitHub
• HashiCorp Learn – Terraform Tutorials
• Terraform Registry – gotowe moduły

Terraform to potężne narzędzie które zmienia sposób myślenia o infrastrukturze. Od ręcznego klikania przechodzisz do kodu, który można testować, wersjonować i wielokrotnie używać. To początek prawdziwego DevOps!

Masz pytania dotyczące Terraform lub Infrastructure as Code? A może już używasz IaC w swoich projektach? Podziel się swoimi doświadczeniami w komentarzach!