Terraform Infrastructure as Code · Lekcja

Wyrażenia warunkowe i splaty

Zaimplementuj logikę warunkową w konfiguracjach za pomocą operatorów trójargumentowych oraz poznaj wyrażenia splat służące do przekształcania list obiektów.

Wyrażenia warunkowe i splaty to bezpłatna lekcja Terraform Infrastructure as Code na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Terraform Infrastructure as Code, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Terraform Infrastructure as Code zawiera 4 lekcji w sumie.

Dynamiczna logika w Terraform

Terraform to nie tylko statyczne deklaracje! Aby konfiguracje infrastruktury były inteligentniejsze i bardziej elastyczne, korzystamy z dynamicznej logiki.

W tej lekcji przedstawiono dwa potężne narzędzia: wyrażenia warunkowe i wyrażenia splat. Pomagają one dostosowywać infrastrukturę do różnych sytuacji oraz wydajnie przekształcać dane.

Wyrażenia warunkowe: podstawy

Wyrażenia warunkowe, często nazywane operatorami trójargumentowymi, pozwalają wybrać jedną z dwóch wartości w zależności od tego, czy warunek jest prawdziwy, czy fałszywy. Działają podobnie jak prosta instrukcja „if-else” dla wartości.

Składnia: condition ? value_if_true : value_if_false
Świetnie nadają się do tworzenia elastycznych i wielokrotnego użytku konfiguracji, które można dostosowywać do różnych środowisk lub ustawień.

Warunek: przykład prostej wartości

Zobaczmy, jak wyrażenie warunkowe może dynamicznie ustawić wartość zmiennej lokalnej na podstawie zmiennej wejściowej. Spróbuj zmienić default = "dev" na default = "prod" i ponownie uruchomić konfigurację.

variable "env" {
  description = "Deployment environment (dev or prod)"
  type        = string
  default     = "dev"
}

locals {
  instance_type = var.env == "prod" ? "t3.medium" : "t3.micro"
}

output "chosen_instance_type" {
  value = local.instance_type
  description = "The instance type selected based on environment."
}

Warunek: przykład atrybutu zasobu

Wyrażeń warunkowych można także używać do sterowania atrybutami zasobów, a nawet do określania, czy zasób w ogóle zostanie utworzony! W tym przykładzie warunkowo tworzymy bucket S3 za pomocą metargumentu count.

variable "create_bucket" {
  description = "Whether to create an S3 bucket"
  type        = bool
  default     = true
}

resource "aws_s3_bucket" "my_bucket" {
  # If create_bucket is true, count is 1 (create one bucket).
  # If create_bucket is false, count is 0 (create no buckets).
  count  = var.create_bucket ? 1 : 0
  bucket = "coddykit-unique-bucket-12345" # IMPORTANT: Replace with a globally unique name!
  acl    = "private"
}

output "bucket_id" {
  value = var.create_bucket ? aws_s3_bucket.my_bucket[0].id : "No bucket created"
  description = "The ID of the created S3 bucket, or a message if not created."
}

Zrozumienie wyrażeń splat

Wyrażenia splat ([*]) służą do przekształcania listy obiektów w listę określonych atrybutów tych obiektów. To wygodny skrót umożliwiający jednoczesne wyodrębnienie danych z wielu elementów.

Składnia: LIST_OF_OBJECTS[*].ATTRIBUTE
Ułatwiają pracę z kolekcjami, takimi jak wiele zasobów utworzonych za pomocą count lub złożone zmienne typu lista.

Splat: przykład wyników zasobów

Wyobraźmy sobie, że tworzysz wiele instancji EC2. Jak łatwo uzyskać listę wszystkich ich publicznych adresów IP? Wyrażenia splat świetnie się do tego nadają! Uwaga: Potrzebny będzie prawidłowy identyfikator AMI dla danego regionu AWS.

resource "aws_instance" "web" {
  count         = 2 # Creates two instances
  ami           = "ami-0abcdef1234567890" # Replace with a valid AMI ID for your region
  instance_type = "t2.micro"
  tags = {
    Name = "web-instance-${count.index}"
  }
}

output "web_instance_public_ips" {
  value = aws_instance.web[*].public_ip
  description = "A list of public IP addresses for all web instances."
}

Splat: przykład list zmiennych

Wyrażenia splat nie służą tylko do pracy z zasobami — świetnie sprawdzają się także w przypadku złożonych zmiennych. W tym przykładzie mamy listę obiektów użytkowników i chcemy wyodrębnić z niej tylko adresy e-mail.

variable "users" {
  description = "List of user objects, each with name, email, and role."
  type = list(object({
    name  = string
    email = string
    role  = string
  }))
  default = [
    { name = "Alice", email = "alice@example.com", role = "admin" },
    { name = "Bob", email = "bob@example.com", role = "viewer" },
    { name = "Charlie", email = "charlie@example.com", role = "editor" }
  ]
}

output "user_emails" {
  value = var.users[*].email
  description = "A list containing only the email addresses of the users."
}

Łączenie warunków i wyrażeń splat

Wyrażenia warunkowe i splat można łączyć, aby tworzyć jeszcze bardziej zaawansowaną i zwięzłą logikę. Można na przykład warunkowo wybrać listę zasobów, a następnie użyć na wybranej liście wyrażenia splat.

Pozwala to tworzyć wysoce elastyczne konfiguracje, które reagują na złożone scenariusze.
Przykład: (var.env == "prod" ? aws_instance.prod : aws_instance.dev)[*].id może pobrać identyfikatory z różnych zestawów instancji w zależności od środowiska.

Najlepsze praktyki dotyczące dynamicznej logiki

Choć dynamiczna logika jest potężnym narzędziem, przy nieostrożnym użyciu może utrudnić zrozumienie konfiguracji. Oto kilka wskazówek:

Zachowaj czytelność: Rozbijaj złożone wyrażenia na mniejsze i łatwiejsze do zarządzania części.
Korzystaj ze zmiennych lokalnych: Zapisuj złożone wyrażenia warunkowe lub splat w blokach locals, aby zwiększyć czytelność i uniknąć powtórzeń.
Dokładnie testuj: Dynamiczna logika może prowadzić do nieoczekiwanego działania. Zawsze uruchamiaj terraform plan i dokładnie analizuj proponowane zmiany.
Dokumentuj: Dodawaj komentarze wyjaśniające złożoną logikę, zwłaszcza podczas łączenia wyrażeń warunkowych i splat.

Szybkie sprawdzenie

Rozważ następującą konfigurację Terraform:

variable "server_names" {
  type    = list(string)
  default = ["web-01", "db-01", "cache-01"]
}

output "filtered_names" {
  value = var.server_names[*]
}

Podsumowanie i kolejne kroki

Świetna praca! Wiesz już, jak sprawić, by konfiguracje Terraform były znacznie bardziej dynamiczne i elastyczne:

Omówiliśmy wyrażenia warunkowe (operator trójargumentowy), które umożliwiają dynamiczne ustalanie wartości na podstawie określonych warunków.
Opanowaliśmy wyrażenia splat ([*]), które pozwalają wydajnie wyodrębniać listy atrybutów z kolekcji obiektów lub zasobów.

Narzędzia te mają fundamentalne znaczenie podczas tworzenia skalowalnej, wielokrotnego użytku i elastycznie dostosowującej się infrastruktury jako kodu. Ćwicz dalej, aby włączyć je do codziennej pracy z Terraform!

Często zadawane pytania

Czy lekcja „Wyrażenia warunkowe i splaty” jest bezpłatna?

Tak — pełny tekst „Wyrażenia warunkowe i splaty” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Terraform Infrastructure as Code, przejdź na CoddyKit PRO. Kurs Terraform Infrastructure as Code zawiera 4 lekcji w sumie.

Co nauczysz się w „Wyrażenia warunkowe i splaty”?

Zaimplementuj logikę warunkową w konfiguracjach za pomocą operatorów trójargumentowych oraz poznaj wyrażenia splat służące do przekształcania list obiektów. Ćwiczysz Terraform Infrastructure as Code z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Terraform Infrastructure as Code?

Nie wymagamy żadnego doświadczenia. Terraform Infrastructure as Code w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Wyrażenia warunkowe i splaty”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Terraform Infrastructure as Code?

Tak. Każda lekcja Terraform Infrastructure as Code zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Korzystanie z pętli `for_each` i `count`
Wbudowane funkcje Terraform
Wyrażenia warunkowe i splaty
Dynamiczne bloki dla zagnieżdżonej konfiguracji

← Powrót do Terraform Infrastructure as Code