Francesco Oghabi

Deploy della Tua Prima Infrastruttura Cloud in 15 Minuti

Scopri come utilizzare Terraform per creare e gestire la tua prima infrastruttura cloud in modo rapido e professionale. Una guida pratica per iniziare subito con l'Infrastructure as Code.

Nel mondo dello sviluppo moderno, la gestione manuale delle infrastrutture cloud è diventata obsoleta e inefficiente. Terraform si è affermato come lo standard de facto per l'Infrastructure as Code (IaC), permettendo agli sviluppatori di definire, versionate e gestire le risorse cloud attraverso codice dichiarativo.

In questa guida pratica, ti accompagneremo attraverso un terraform quickstart completo che ti permetterà di deployare la tua prima infrastruttura cloud funzionante in soli 15 minuti. Non importa se sei alle prime armi con Terraform o se vuoi rinfrescare le tue conoscenze: questa guida ti fornirà tutte le basi necessarie per iniziare.

Cos'è Terraform e Perché Utilizzarlo

Terraform è un tool open-source sviluppato da HashiCorp che permette di definire e gestire infrastrutture cloud attraverso file di configurazione. Utilizza un linguaggio dichiarativo chiamato HashiCorp Configuration Language (HCL) che descrive lo stato desiderato delle risorse, piuttosto che i passi procedurali per raggiungerlo.

Vantaggi Principali di Terraform

  • Multi-cloud: Supporta oltre 1000 provider diversi (AWS, Azure, Google Cloud, Kubernetes, ecc.)
  • State Management: Mantiene traccia dello stato delle risorse per gestire modifiche e aggiornamenti
  • Plan and Apply: Visualizza le modifiche prima di applicarle
  • Riproducibilità: Le configurazioni possono essere versionate e condivise
  • Modularità: Supporta moduli riutilizzabili per componenti comuni

Prerequisiti e Setup Iniziale

Prima di iniziare con il nostro terraform quickstart, assicurati di avere i seguenti prerequisiti:

Installazione di Terraform

Per installare Terraform sul tuo sistema:

Sistema Operativo Comando di Installazione
macOS (Homebrew) brew install terraform
Ubuntu/Debian sudo apt-get install terraform
Windows (Chocolatey) choco install terraform

Verifica l'installazione eseguendo:

terraform --version

Configurazione del Provider Cloud

Per questo tutorial utilizzeremo AWS, ma i concetti sono applicabili a qualsiasi provider. Assicurati di avere:

  • Un account AWS attivo
  • AWS CLI configurato con le credenziali appropriate
  • Permessi sufficienti per creare risorse EC2 e VPC
aws configure
# Inserisci le tue credenziali AWS quando richiesto

Creazione della Prima Configurazione Terraform

Iniziamo creando la struttura base del nostro progetto Terraform. Crea una nuova directory e i file necessari:

mkdir terraform-quickstart
cd terraform-quickstart
touch main.tf variables.tf outputs.tf

Configurazione del Provider

Nel file main.tf, iniziamo definendo il provider AWS:

terraform {
  required_version = ">= 1.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
}

provider "aws" {
  region = var.aws_region
}

# Data source per ottenere l'AMI più recente di Amazon Linux
data "aws_ami" "amazon_linux" {
  most_recent = true
  owners      = ["amazon"]

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

Definizione delle Variabili

Nel file variables.tf, definiamo le variabili che useremo:

variable "aws_region" {
  description = "AWS region per le risorse"
  type        = string
  default     = "eu-west-1"
}

variable "instance_type" {
  description = "Tipo di istanza EC2"
  type        = string
  default     = "t2.micro"
}

variable "project_name" {
  description = "Nome del progetto per i tag"
  type        = string
  default     = "terraform-quickstart"
}

Creazione dell'Infrastruttura Base

Ora implementiamo l'infrastruttura vera e propria. Aggiungiamo al file main.tf le risorse necessarie:

Virtual Private Cloud (VPC)

# VPC
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name = "${var.project_name}-vpc"
  }
}

# Internet Gateway
resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name = "${var.project_name}-igw"
  }
}

# Subnet pubblica
resource "aws_subnet" "public" {
  vpc_id                  = aws_vpc.main.id
  cidr_block              = "10.0.1.0/24"
  availability_zone       = data.aws_availability_zones.available.names[0]
  map_public_ip_on_launch = true

  tags = {
    Name = "${var.project_name}-public-subnet"
  }
}

# Data source per le zone di disponibilità
data "aws_availability_zones" "available" {
  state = "available"
}

Routing e Security Groups

# Route table
resource "aws_route_table" "public" {
  vpc_id = aws_vpc.main.id

  route {
    cidr_block = "0.0.0.0/0"
    gateway_id = aws_internet_gateway.main.id
  }

  tags = {
    Name = "${var.project_name}-public-rt"
  }
}

# Associazione route table
resource "aws_route_table_association" "public" {
  subnet_id      = aws_subnet.public.id
  route_table_id = aws_route_table.public.id
}

# Security Group
resource "aws_security_group" "web" {
  name        = "${var.project_name}-web-sg"
  description = "Security group per server web"
  vpc_id      = aws_vpc.main.id

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

  ingress {
    from_port   = 22
    to_port     = 22
    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 = "${var.project_name}-web-sg"
  }
}

Istanza EC2

# Key pair per SSH
resource "aws_key_pair" "main" {
  key_name   = "${var.project_name}-key"
  public_key = file("~/.ssh/id_rsa.pub") # Assicurati che questo file esista
}

# Istanza EC2
resource "aws_instance" "web" {
  ami                    = data.aws_ami.amazon_linux.id
  instance_type          = var.instance_type
  subnet_id              = aws_subnet.public.id
  vpc_security_group_ids = [aws_security_group.web.id]
  key_name               = aws_key_pair.main.key_name

  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 = "${var.project_name}-web-server"
  }
}

Output e Risultati

Nel file outputs.tf, definiamo gli output utili:

output "vpc_id" {
  description = "ID del VPC creato"
  value       = aws_vpc.main.id
}

output "instance_ip" {
  description = "IP pubblico dell'istanza"
  value       = aws_instance.web.public_ip
}

output "instance_dns" {
  description = "DNS pubblico dell'istanza"
  value       = aws_instance.web.public_dns
}

output "website_url" {
  description = "URL del sito web"
  value       = "http://${aws_instance.web.public_dns}"
}

Deploy dell'Infrastruttura

Ora è il momento di fare il deploy della nostra infrastruttura. Segui questi passaggi:

Passo 1: Inizializzazione

terraform init

Questo comando scarica i provider necessari e inizializza la directory di lavoro.

Passo 2: Pianificazione

terraform plan

Il comando plan mostra le modifiche che Terraform intende apportare senza applicarle effettivamente.

Passo 3: Applicazione

terraform apply

Terraform ti mostrerà il piano e chiederà conferma. Digita "yes" per procedere con il deploy.

Verifica del Deploy

Una volta completato il deploy, Terraform mostrerà gli output definiti. Puoi testare l'infrastruttura visitando l'URL fornito nell'output website_url.

Best Practices per Terraform

Ora che hai completato il tuo primo terraform quickstart, ecco alcune best practices da seguire:

Gestione dello State

  • Utilizza un backend remoto (S3, Terraform Cloud) per lo state file
  • Attiva il versioning per il backend
  • Implementa il locking dello state per evitare conflitti

Organizzazione del Codice

  • Separa le configurazioni per ambiente (dev, staging, prod)
  • Utilizza moduli per componenti riutilizzabili
  • Versiona le tue configurazioni con Git

Sicurezza

  • Non committare mai credenziali nel codice
  • Utilizza variabili d'ambiente o servizi di gestione segreti
  • Applica il principio del minimo privilegio per i permessi

Cleanup delle Risorse

Per evitare costi non necessari, ricordati di distruggere le risorse quando hai finito:

terraform destroy

Questo comando rimuoverà tutte le risorse create, assicurandoti di non incorrere in costi aggiuntivi.

Conclusioni

Congratulazioni! Hai appena completato il tuo primo terraform quickstart e deployato con successo un'infrastruttura cloud completa in meno di 15 minuti. Hai imparato i concetti fondamentali di Terraform, dalla configurazione iniziale al deploy delle risorse, passando per la gestione degli output e le best practices.

Terraform è uno strumento potente che diventa ancora più utile quando applicato a scenari reali più complessi. I concetti che hai appreso in questa guida - provider, risorse, variabili, output e gestione dello state - sono i mattoni fondamentali per costruire infrastrutture cloud robuste e scalabili.

Il prossimo passo è esplorare funzionalità più avanzate come i moduli Terraform, la gestione di stati remoti, e l'integrazione con pipeline CI/CD. Ricorda sempre di seguire le best practices di sicurezza e di organizzazione del codice mentre sviluppi le tue competenze con Infrastructure as Code.

Continua a esplorare la documentazione ufficiale di Terraform e sperimenta con diversi provider e configurazioni. L'ecosistema Terraform è vasto e in continua evoluzione, offrendo sempre nuove opportunità per ottimizzare e automatizzare la gestione delle infrastrutture cloud.