Moduły Terraforma

Moduly Terraforma



W świecie udostępniania i zarządzania infrastrukturą Terraform stał się popularnym wyborem wśród programistów i zespołów operacyjnych. Dzięki deklaratywnej składni (HCL – HashiCorp Configuration Language) i wsparciu dla różnych dostawców infrastruktury, Terraform umożliwia praktyki infrastruktury jako kodu (IaC).

Jedną z jego kluczowych cech jest wykorzystanie modułów pozwalających na tworzenie i ponowne wykorzystywanie modułowego kodu infrastruktury. W tym artykule przyjrzymy się koncepcji modułów Terraform oraz temu, jak mogą one pomóc w uporządkowaniu i uproszczeniu naszego kodu infrastruktury.







Wprowadzenie do modułów Terraform

Moduły Terraform to samodzielne pakiety konfiguracji Terraform, które reprezentują zestaw zasobów ze zdefiniowanymi zmiennymi wejściowymi i wyjściowymi. Zapewniają sposób hermetyzacji i ponownego wykorzystania kodu infrastruktury, co ułatwia zarządzanie i konserwację złożonych wdrożeń infrastruktury.



Moduły mogą być tworzone i używane wewnętrznie w ramach projektu lub udostępniane w wielu projektach lub zespołach.



Organizacja modułu

Podczas organizowania modułów Terraform często stosuje się hierarchiczną strukturę składającą się z modułów głównych i podrzędnych. Przyjrzyjmy się, jak działa ta organizacja.





Moduł główny



Moduł główny reprezentuje moduł najwyższego poziomu w naszej konfiguracji Terraform. Jest to punkt wejścia do definiowania ogólnej infrastruktury i zarządzania relacjami między różnymi zasobami.

Moduł główny zazwyczaj zawiera plik „main.tf”, w którym definiujemy zasoby i konfiguracje, które stanowią podstawę naszej infrastruktury. Opcjonalnie możemy mieć przy sobie pliki „variables.tf” i „outputs.tf”. Możemy również zdefiniować nasz katalog „modułów” w katalogu głównym, aby łatwo uzyskać dostęp do modułów potomnych.

Moduły podrzędne

Moduły podrzędne to komponenty modułowe, które zawierają określone zestawy zasobów lub konfiguracje. Zostały zaprojektowane tak, aby nadawały się do wielokrotnego użytku i reprezentowały samodzielne jednostki funkcjonalności infrastruktury.

Moduły potomne mogą być używane w module głównym lub innych modułach potomnych, które umożliwiają kompozycję i budowanie złożonej infrastruktury. Każdy moduł podrzędny zazwyczaj ma swój katalog zawierający niezbędne pliki konfiguracyjne, takie jak „main.tf”, „variables.tf” i „outputs.tf”.

Zobaczmy teraz, jak możemy stworzyć moduł Terraform.

Tworzenie modułu Terraform

Podczas tworzenia modułów Terraform musimy stworzyć dla modułu nowy katalog z wymaganymi plikami konfiguracyjnymi Terraform. Zwykle ten katalog nosi nazwę „moduły”. Definiowanie go w katalogu głównym naszego projektu to najlepsza praktyka.

Weźmy prosty przykład prostego modułu udostępniającego lokalny serwer WWW za pomocą Dockera. Najpierw definiujemy moduł w katalogu „modules” jako „main.tf”.

ratunek 'docker_container' 'serwer internetowy' {
nazwa  = nazwa.zm
obraz = var.obraz
porty {
wewnętrzny = var.port_wewnętrzny
zewnętrzny = var.zewnętrzny_port
}
}

Tutaj tworzymy moduł o nazwie „docker_container”, który pobiera nazwę kontenera, obraz Dockera, port wewnętrzny i port zewnętrzny jako zmienne wejściowe. Moduł hermetyzuje logikę tworzenia zasobu kontenera Docker i umożliwia wywołującemu dostosowanie właściwości kontenera.

Jak pokazano na poniższym obrazku, tworzymy osobny plik o nazwie „variables.tf” w katalogu „moduły”, aby zdefiniować zmienne wejściowe, które można dostosować podczas korzystania z modułu:

zmienny 'nazwa' {
opis = „Nazwa kontenera Dockera”
typ = ciąg
}

zmienny 'obraz' {
opis = „Obraz Dockera”
typ = ciąg
}

zmienny 'Port wewnętrzny' {
opis = „Port wewnętrzny w kontenerze Docker”
typ = liczba
}

zmienny 'port_zewnętrzny' {
opis = „Port zewnętrzny do zmapowania”
typ = liczba
}

Tutaj zadeklarowaliśmy cztery zmienne, każda z „opisem” i „typem” jako atrybutami i odpowiednimi dla nich wartościami.

Korzystanie z modułu Terraform

Odkąd stworzyliśmy nasz moduł, możemy teraz używać go w naszej głównej konfiguracji Terraform, odwołując się do jego źródła. Utwórzmy nasz główny plik konfiguracyjny, którym jest „main.tf” w katalogu głównym.

moduł 'kontener_serwera sieciowego' {
źródło = '../modules/docker_container'
nazwa            = „mój serwer WWW”
obraz           = „nginx: najnowszy”
port_wewnętrzny   = 80
port_zewnętrzny   = 8080
}

Używamy bloku „module” w poprzednim kodzie, aby utworzyć instancję modułu kontenera Docker. Dostarczamy niezbędne wartości wejściowe dla modułu, takie jak nazwa kontenera, obraz Dockera i konfiguracja portu. Parametr „source” określa względną ścieżkę do katalogu „moduł”.

Następnie zobaczmy, jak wykorzystać dane wyjściowe Terraform do użycia z modułami.

Wyjścia modułu

Dane wyjściowe modułów w Terraform zapewniają sposób na ujawnienie określonych wartości z modułu, udostępniając je do użycia w konfiguracji głównej lub przez inne moduły. Służą one jako kanał komunikacyjny pomiędzy modułem a dzwoniącym, który umożliwia modułowi przekazanie informacji lub danych, które mogą być przydatne lub niezbędne do dalszej konfiguracji lub podjęcia decyzji.

wyjście 'identyfikator_kontenera' {
opis = „Identyfikator utworzonego kontenera Docker”
wartość       = docker_container.webserver.id
}

Tutaj utworzyliśmy plik „outputs.tf” w katalogu „moduły”. Ta zmienna wyjściowa ujawnia identyfikator kontenera Docker, który jest tworzony przez zasób „docker_container” o nazwie „webserver” w module.

Teraz możemy uzyskać dostęp do identyfikatora kontenera w naszym głównym pliku konfiguracyjnym. Zapoznaj się z następującym zaktualizowanym kodem pliku „main.tf” w katalogu głównym:

moduł 'kontener_serwera sieciowego' {
źródło = '../modules/docker_container'
nazwa            = „mój serwer WWW”
obraz           = „nginx: najnowszy”
port_wewnętrzny   = 80
port_zewnętrzny   = 8080
}

ratunek 'Docker_volume' 'dane' {
# Reszta argumentów idzie tutaj
wiązać = module.webserver_container.container_id
}

Używając „module.webserver_container.container_id” jako wartości argumentu „bind”, instruujemy Terraform, aby powiązał wolumin Dockera z lokalizacją określoną przez identyfikator kontenera modułu „web_container”. Ustanawia to relację między zasobem woluminu Docker a kontenerem tworzonym przez moduł „webserver_container”, zapewniając, że wolumin jest zamontowany we właściwej lokalizacji.

Najlepsze praktyki dotyczące modułów Terraform

Modularyzuj w celu ponownego użycia

Projektując moduły, powinniśmy wziąć pod uwagę możliwość ponownego wykorzystania. Musimy również zidentyfikować logiczne komponenty lub wzorce naszej infrastruktury i umieścić je w osobnych modułach. Sprzyja to ponownemu wykorzystaniu kodu, standaryzacji i łatwiejszej współpracy między zespołami.

Jasne i spójne nazewnictwo

Stosowanie jasnych i spójnych konwencji nazewnictwa modułów, zmiennych i zasobów poprawia czytelność i zrozumienie bazy kodu, co ułatwia innym pracę z modułami i ich konserwację.

Izoluj zależności

Musimy unikać ścisłego powiązania między modułami. Każdy moduł powinien hermetyzować własne zasoby i zależności. Gwarantuje to, że moduły mogą być ponownie używane niezależnie i promuje lepszą izolację i hermetyzację.

Kontrola wersji i rejestr modułów

Możemy opublikować nasze moduły w repozytorium z kontrolą wersji lub w rejestrze modułów. Zapewnia to scentralizowaną lokalizację do udostępniania i odkrywania modułów, zapewniając łatwy dostęp i wersjonowanie.

Wniosek

Zrobiliśmy krótkie wprowadzenie do modułów Terraform i nauczyliśmy się, jak je tworzyć na prostym przykładzie. Następnie przyjrzeliśmy się, jak używać zmiennych i danych wyjściowych w naszym module, aby zwiększyć jego elastyczność, możliwość ponownego użycia i łatwość konserwacji. Podsumowując, moduły Terraform to potężne narzędzia do organizowania i upraszczania kodu infrastruktury. Pozwalają nam zamknąć zestaw zasobów lub konfiguracji w komponentach wielokrotnego użytku, promując modułowość, możliwość ponownego wykorzystania i współpracę w ramach naszych projektów infrastruktury jako kodu.