De auteur heeft de Wikimedia Foundation geselecteerd om een donatie te ontvangen als onderdeel van het Write for Donations-programma.
Introductie
Infrastructure as Code (IaC) is een praktijk van het automatiseren van de implementatie en aanpassingen van infrastructuur door de status van de resources en hun relaties in code te definiëren. Door die code uit te voeren, worden de daadwerkelijke resources in de cloud gecreëerd of gewijzigd. Met IaC kunnen ingenieurs een IaC-tool zoals Terraform (van HashiCorp) gebruiken voor de voorziening van infrastructuur.
Met IaC kunnen wijzigingen in uw infrastructuur door hetzelfde codebeoordelingsproces gaan als uw toepassingscode. U kunt de code opslaan in versiebeheer (zoals Git) om een geschiedenis van de status van uw infrastructuur bij te houden, en u kunt het implementatieproces verder automatiseren met meer geavanceerde tools zoals een zelfbedienings-intern ontwikkelaarsplatform (IDP).
Terraform is een populair platformonafhankelijk IaC-hulpmiddel vanwege de brede ondersteuning voor veel platforms, waaronder GitHub, Cloudflare en DigitalOcean. De meeste Terraform-configuraties worden geschreven met een declaratieve taal genaamd de HashiCorp Configuration Language (HCL).
De Cloud Development Kit for Terraform (CDKTF) is een hulpmiddel gebouwd bovenop Terraform waarmee je infrastructuur kunt definiëren met behulp van een vertrouwde programmeertaal (zoals TypeScript, Python of Go) in plaats van HCL. Dit hulpmiddel kan een minder steile leercurve bieden voor ontwikkelaars die niet bekend zijn met HCL, terwijl het ontwikkelaars in staat stelt om native programmeerfuncties zoals loops, variabelen en functies te gebruiken.
In deze tutorial begin je met het installeren van de cdktf command-line interface (CLI) tool. Vervolgens zul je een CDKTF-project in TypeScript maken en het project definiëren met twee NGINX-servers die worden gebalanceerd door een load balancer. Daarna zul je cdktf gebruiken om de infrastructuur uit te rollen. Aan het einde van deze tutorial heb je een CDKTF-project waarvan je kunt uitbreiden om je infrastructuur uit te breiden.
Opmerking: Deze tutorial is getest met CDKTF 0.11.2 en Terraform 1.2.2.
Vereisten
Om deze tutorial te voltooien, heb je het volgende nodig:
- A good understanding of Infrastructure-as-Code (IaC). You can learn about IaC in Infrastructure as Code Explained.
- A DigitalOcean account. If you do not have one, sign up for a new account.
- A DigitalOcean Personal Access Token, which you can create via the DigitalOcean console. Instructions on how to do that can be found at How to Generate a Personal Access Token.
- A password-less SSH key added to your DigitalOcean account. You can add that by following How To Use SSH Keys with DigitalOcean Droplets. When you add the key to your account, remember the name you give it, as you will need it in this tutorial. For CDKTF to accept the name of your key, it must start with a letter or underscore and may contain only letters, digits, underscores, and dashes.
- Terraform geïnstalleerd op je lokale machine, wat je kunt instellen met “Stap 1 – Terraform installeren” in Hoe Terraform te gebruiken met DigitalOcean.
- Node.js geïnstalleerd op je lokale machine. Instructies hiervoor vind je in de serie Hoe Node.js te installeren en een lokale ontwikkelomgeving te maken.
- Comfortabel zijn met programmeren in JavaScript. Om je vaardigheden op te bouwen, bekijk de serie Hoe te coderen in JavaScript.
- Comfortabel zijn met de basisfuncties van TypeScript. Als je niet bekend bent met TypeScript, is de zelfstudie serie Hoe te coderen in TypeScript een goede bron om je snel bij te spijkeren.
- A code editor or integrated development environment (IDE) that supports TypeScript. If you are not currently using one, try Visual Studio Code. You can also read up on How To Work With TypeScript in Visual Studio Code.
Stap 1 — Het installeren van de cdktf CLI
Om te beginnen, installeer je de cdktf command-line tool.
De cdktf CLI is beschikbaar als een NPM-pakket. Als je zoekt naar cdktf op npmjs.com, vind je twee vergelijkbaar genaamde pakketten: cdktf en cdktf-cli.
Conceptueel is CDKTF een abstractielaag bovenop Terraform. Het bestaat uit twee delen:
-
een bibliotheek met een set van taal-natieve constructies (zoals functies en klassen) voor het definiëren van infrastructuur. Dit deel is ingekapseld binnen het
cdktfnpm-pakket. Bijvoorbeeld, je kunt het gebruik zien van deAppenTerraformStackklassen van hetcdktfpakket in het volgende voorbeeld CDKTF project: -
een adapter die de constructies binnen het CDKTF-project analyseert en ze terugbrengt tot een reeks JSON-documenten, die vervolgens op dezelfde manier in Terraform worden ingevoerd als HCL. Deze adapter is ingekapseld in een CLI-tool genaamd
cdktf, geleverd door hetcdktf-clipakket.
Om de cdktf CLI-tool te installeren, heb je het cdktf-cli pakket nodig. Je kunt dit pakket wereldwijd installeren met npm, yarn, of een pakketbeheerder naar keuze.
Om cdktf-cli te installeren met npm, voer je het volgende uit:
Let op: Er zal waarschijnlijk een nieuwere versie van het cdktf-cli pakket zijn na de publicatie van dit artikel. Je kunt proberen de tutorial met de nieuwste versie te volgen door in plaats daarvan npm install --global cdktf-cli@latest uit te voeren, maar wees ervan bewust dat sommige uitvoer mogelijk iets afwijkt.
Je kunt ook Homebrew op macOS of Linux gebruiken om de cdktf CLI te installeren als het cdktf formulier:
Om te controleren of de installatie succesvol is, voer je het cdktf commando uit zonder argumenten:
Je zult een output zien die vergelijkbaar is met het volgende:
OutputPlease pass a command to cdktf, here are all available ones:
cdktf
Commands:
cdktf init Create a new cdktf project from a template.
cdktf get Generate CDK Constructs for Terraform providers and modules.
cdktf convert Converts a single file of HCL configuration to CDK for Terraform.
cdktf deploy [stacks...] Deploy the given stacks
cdktf destroy [stacks..] Destroy the given stacks
cdktf diff [stack] Perform a diff (terraform plan) for the given stack
cdktf list List stacks in app.
cdktf login Retrieves an API token to connect to Terraform Cloud.
cdktf synth Synthesizes Terraform code for the given app in a directory.
cdktf watch [stacks..] [experimental] Watch for file changes and automatically trigger a deploy
cdktf output [stacks..] Prints the output of stacks
cdktf debug Get debug information about the current project and environment
cdktf completion generate completion script
Options:
--version Toon versienummer
--disable-logging Schrijf geen logbestanden. Ondersteund met behulp van de omgevingsvariabele CDKTF_DISABLE_LOGGING.
--disable-plugin-cache-env Stel TF_PLUGIN_CACHE_DIR niet automatisch in.
--log-level Welk logniveau moet worden geschreven.
-h, --help Show help
Options can be specified via environment variables with the "CDKTF_" prefix (e.g. "CDKTF_OUTPUT")
De output toont de beschikbare commando’s. In de rest van deze tutorial zul je ervaring opdoen met het gebruik van cdktf init, cdktf get, cdktf deploy en cdktf destroy.
Nu je de cdktf CLI hebt geïnstalleerd, kun je infrastructuur definiëren door wat TypeScript-code te schrijven.
Stap 2 — Het aanmaken van een nieuw CDKTF-project
In deze stap zul je de zojuist geïnstalleerde cdktf CLI gebruiken om een basis CDKTF-project aan te maken, waar je in de volgende stappen op zult voortbouwen.
Maak een map aan waarin het CDKTF-project wordt gehuisvest door het volgende commando uit te voeren:
Navigeer vervolgens naar de zojuist aangemaakte map:
Gebruik het cdktf init-commando om een CDKTF-project-skelet aan te maken waar je op voortbouwt:
CDKTF stelt ontwikkelaars in staat infrastructuur te definiëren met behulp van TypeScript, Python, Java, C# of Go. De optie --template=typescript vertelt cdktf om dit CDKTF-project te genereren met behulp van TypeScript.
Terraform (en dus CDKTF) houdt bij welke resources het beheert door hun definities en statussen op te nemen in bestanden genaamd Terraform-state-bestanden. De optie --local vertelt CDKTF om deze statusbestanden lokaal te bewaren op de machine waarop cdktf wordt uitgevoerd (elk bestand volgt de benamingstructuur terraform.<stack>.tfstate).
Na het uitvoeren van het commando kan de CLI je om toestemming vragen om crashrapporten naar het CDKTF-team te sturen om hen te helpen het product te verbeteren:
Output? Do you want to send crash reports to the CDKTF team? See https://www.terraform.io/cdktf/create-and-deploy/configuration-file for
more information (Y/n)
Type Y als je akkoord gaat of N als je het er niet mee eens bent, en druk vervolgens op ENTER.
cdktf zal vervolgens het project scaffolding maken en de pakketten installeren. Wanneer het project is gescaffold, zie je een uitvoer vergelijkbaar met het volgende:
Output Your cdktf typescript project is ready!
cat help Print this message
Compile:
npm run get Import/update Terraform providers and modules (you should check-in this directory)
npm run compile Compile typescript code to javascript (or "npm run watch")
npm run watch Watch for changes and compile typescript in the background
npm run build Compile typescript
Synthesize:
cdktf synth [stack] Synthesize Terraform resources from stacks to cdktf.out/ (ready for 'terraform apply')
Diff:
cdktf diff [stack] Perform a diff (terraform plan) for the given stack
Deploy:
cdktf deploy [stack] Deploy the given stack
Destroy:
cdktf destroy [stack] Destroy the stack
Test:
npm run test Runs unit tests (edit __tests__/main-test.ts to add your own tests)
npm run test:watch Watches the tests and reruns them on change
Upgrades:
npm run upgrade Upgrade cdktf modules to latest version
npm run upgrade:next Upgrade cdktf modules to latest "@next" version (last commit)
Je zult ook enkele nieuwe bestanden zien toegevoegd aan de infra-directory. De belangrijkste bestanden zijn cdktf.json en main.ts.
cdktf.json is het configuratiebestand voor het CDKTF-project. Als je het bestand opent, zal het iets tonen als het volgende:
De eigenschap app definieert het commando dat wordt uitgevoerd om de TypeScript-code te synthesizeren naar Terraform-compatibele JSON. Deze eigenschap geeft aan dat main.ts het startpunt is voor het CDKTF-project.
Als je het bestand main.ts opent, zul je iets soortgelijks zien als het volgende:
In de taal van CDKTF kunnen een verzameling gerelateerde infrastructuurresources worden gegroepeerd in een stack. Bijvoorbeeld, de resources die een API-toepassing vormen, zoals Droplets, load balancers en DNS-records, kunnen worden gegroepeerd in een enkele stack genaamd APIStack. Elke stack houdt zijn eigen staat bij en kan onafhankelijk van andere stacks worden ingezet, gewijzigd of vernietigd. Een veelvoorkomend gebruik van stacks is om één stack voor productie te hebben en een aparte stack voor ontwikkeling.
Een applicatie is een container voor meerdere stacks. Bijvoorbeeld, een applicatie kan de stacks van verschillende microservices groeperen.
De CDKTF-project-scaffold die is gegenereerd in main.ts bevat een enkele stackklasse genaamd MyStack, die momenteel geen resources definieert. Een instantie van MyStack wordt aangemaakt met de naam infra, opgenomen in een applicatie genaamd app. In de volgende stappen zul je infrastructuurresources definiëren binnen de constructor van MyStack.
Na het maken van het project is de volgende stap het configureren van het CDKTF-project met providers.
Stap 3 — Het installeren van de DigitalOcean-provider
In deze stap installeer je de DigitalOcean Provider in het CDKTF-project.
Providers zijn bibliotheken die instructies bieden aan Terraform (dat onder de motorkap door cdktf wordt gebruikt) over hoe bronnen moeten worden aangemaakt, bijgewerkt en verwijderd op cloudproviders, SaaS-providers en andere platforms die application programming interfaces (API’s) blootstellen. Providers omvatten de logica om deze upstream-API’s aan te roepen in standaardfuncties die Terraform kan aanroepen.
Bijvoorbeeld, als je een nieuwe DigitalOcean Droplet zou willen maken zonder Terraform, zou je een POST-verzoek moeten sturen naar de /v2/droplets endpoint van de DigitalOcean API. Met Terraform zou je in plaats daarvan de DigitalOcean-provider installeren en een digitalocean_droplet-bron definiëren, vergelijkbaar met het volgende voorbeeldfragment:
Vervolgens kun je de cdktf CLI-tool gebruiken om deze TypeScript-code om te zetten in Terraform-compatibele JSON en deze door te geven aan de provider, die namens jou de juiste API-aanroepen zal doen om de Droplet aan te maken.
Nu je begrijpt wat een provider is, kun je de DigitalOcean-provider instellen voor je CDKTF-project.
Open het bestand cdktf.json en voeg de string digitalocean/digitalocean toe aan de array terraformProviders:
digitalocean/digitalocean is de identificator voor de DigitalOcean-provider op de Terraform-registry.
Sla het bestand op en sluit het.
Vervolgens voert u cdktf get uit om de provider te downloaden en te installeren.
cdktf get zal de provider downloaden, het schema extraheren, de overeenkomstige TypeScript-klassen genereren en deze toevoegen als een TypeScript-module onder .gen/providers/. Deze automatische codegeneratie maakt het mogelijk om alle Terraform-providers en HCL-modules te gebruiken met CDKTF, en dit is hoe CDKTF code-aanvulling kan bieden in editors die dit ondersteunen.
Zodra cdktf get klaar is met uitvoeren, ziet u uitvoer vergelijkbaar met het volgende:
OutputGenerated typescript constructs in the output directory: .gen
U ziet ook een nieuwe map genaamd .gen met de gegenereerde code van de provider.
In deze stap heeft u de digitalocean/digitalocean-provider in het project geïnstalleerd. In de volgende stap gaat u de DigitalOcean-provider configureren met de referenties die nodig zijn om de provider te authenticeren bij de DigitalOcean API.
Stap 4 — Configuratie van de DigitalOcean-provider
In deze stap configureert u de DigitalOcean-provider met uw DigitalOcean-persoonlijke toegangstoken, waarmee de provider namens u de DigitalOcean API kan aanroepen.
Verschillende providers vereisen en ondersteunen verschillende referenties voor authenticatie met de upstream API. Voor de DigitalOcean-provider moet u uw DigitalOcean-persoonlijke toegangstoken opgeven. U kunt de token aan de provider doorgeven door deze in te stellen als de DIGITALOCEAN_TOKEN of DIGITALOCEAN_ACCESS_TOKEN omgevingsvariabelen.
Voer de volgende opdracht uit in uw terminal om de omgevingsvariabele in te stellen voor die terminalsessie.
Opmerking: Door export te gebruiken, stelt u de omgevingsvariabele alleen in voor die terminalsessie. Als u de terminal sluit en opnieuw opent of de cdktf-opdrachten uitvoert in een andere terminal, moet u de export-opdracht opnieuw uitvoeren om de omgevingsvariabele van kracht te laten worden.
Vervolgens zult u de provider specificeren binnen de MyStack-klasse, waarmee u bronnen die door de provider worden geleverd binnen uw stack kunt definiëren. Werk het bestand main.ts bij naar het volgende:
De module voor de provider bevindt zich in ./.gen/providers/digitalocean, die automatisch is gegenereerd toen u cdktf get uitvoerde.
U heeft de digitalocean/digitalocean-provider geconfigureerd met referenties in deze stap. Vervolgens zult u beginnen met het definiëren van de infrastructuur die deel uitmaakt van het doel van deze handleiding.
Stap 5 — Definiëren van Webapplicaties op Droplets
In deze stap definieer je twee NGINX-servers, die elk verschillende bestanden bedienen, ingezet op twee identieke Ubuntu 20.04 Droplets.
Je begint met de definitie van de twee Droplets. Pas main.ts aan met de gemarkeerde wijzigingen:
Je gebruikt een JavaScript-native loop (Array.prototype.map()) om duplicatie in de code te vermijden.
Net zoals bij het maken van de Droplet via de console, zijn er verschillende parameters om te specificeren:
image– de Linux distributie en versie waarop je Droplet zal draaien.regio– het datacenter waar de Droplet zal draaien.grootte– de hoeveelheid CPU- en geheugenbronnen die je aan de Droplet wilt toewijzen.naam– een unieke naam die wordt gebruikt om naar de Droplet te verwijzen.
De waarden voor image, region en size moeten zaken zijn die DigitalOcean ondersteunt. U kunt de geldige waarden (genaamd slugs) vinden voor alle ondersteunde Linux distributie-images, Droplet formaten en regio’s op de DigitalOcean API Slugs pagina. U kunt een volledige lijst van vereiste en optionele attributen vinden op de digitalocean_droplet documentatiepagina.
Het toevoegen van een SSH-sleutel
Als onderdeel van de vereisten heeft u een SSH openbare sleutel zonder wachtwoord geüpload naar uw DigitalOcean account en de naam genoteerd. U zult nu die naam gebruiken om de ID van de SSH-sleutel op te halen en deze door te geven in de definitie van uw Droplet.
Aangezien de SSH-sleutel handmatig aan uw DigitalOcean account is toegevoegd, is het geen bron die wordt beheerd door uw huidige Terraform-configuratie. Als u zou proberen een nieuwe digitalocean_ssh_key bron te definiëren, zou het een nieuwe SSH-sleutel maken in plaats van de bestaande te gebruiken.
In plaats daarvan zul je een nieuwe digitalocean_ssh_key gegevensbron definiëren. In Terraform worden gegevensbronnen gebruikt om informatie op te halen over infrastructuur die niet wordt beheerd door de huidige Terraform-configuratie. Met andere woorden, ze bieden een alleen-lezen weergave van de staat van bestaande externe infrastructuur. Zodra een gegevensbron is gedefinieerd, kun je de gegevens elders in je Terraform-configuratie gebruiken.
Nog steeds in main.ts en binnen de constructor van MyStack, definieer een nieuwe DataDigitaloceanSshKey gegevensbron en geef de naam door die je aan je SSH-sleutel hebt toegewezen (hier is de naam do_cdktf):
Vervolgens, update de definitie van de Droplet om de SSH-sleutel op te nemen:
Als het is provisioned, kun je toegang krijgen tot de Droplet met behulp van een privé SSH-sleutel in plaats van een wachtwoord.
Het specificeren van gebruikersgegevensscript om NGINX te installeren
Je hebt nu twee identieke Droplets gedefinieerd die Ubuntu draaien, geconfigureerd met SSH-toegang. De volgende taak is om NGINX op elke Droplet te installeren.
Wanneer een Droplet wordt gemaakt, zal een tool genaamd CloudInit de server initialiseren. CloudInit kan een bestand genaamd gebruikersgegevens accepteren, waarmee de initialisatie van de server kan worden gewijzigd. De gebruikersgegevens kunnen elk cloud-config-bestand of scripts zijn die de server kan interpreteren, zoals Bash-scripts.
In de rest van deze stap maakt u een Bash-script en specificeert u dit als de gebruikersgegevens van de Droplet. Het script zal NGINX installeren als onderdeel van het initialisatieproces. Bovendien zal het script ook de inhoud van het bestand /var/www/html/index.html (het standaardbestand dat door NGINX wordt geserveerd) vervangen door de hostnaam en het IP-adres van de Droplet, waardoor de twee NGINX-servers verschillende bestanden zullen serveren. In de volgende stap plaatst u beide van deze NGINX-servers achter een load balancer; door verschillende bestanden te serveren, wordt het duidelijk of de load balancer de verzoeken correct verdeelt of niet.
Nog steeds in main.ts, voeg een nieuwe userData-eigenschap toe aan het configuratieobject van de Droplet:
Waarschuwing: Zorg ervoor dat er geen nieuwe regels zijn vóór de shebang (#!); anders wordt het script mogelijk niet uitgevoerd.
Wanneer de Droplet voor het eerst wordt ingericht, wordt het script uitgevoerd als de gebruiker root. Het zal de pakketbeheerder van Ubuntu, APT, gebruiken om het pakket nginx te installeren. Vervolgens zal het de Metadata Service van DigitalOcean gebruiken om informatie over zichzelf op te halen en de hostnaam en IP-adres in index.html schrijven, dat wordt geserveerd door NGINX.
In deze stap hebt u de twee Droplets gedefinieerd die Ubuntu uitvoeren, elk geconfigureerd met SSH-toegang, en NGINX geïnstalleerd met behulp van de functie voor gebruikersgegevens. In de volgende stap zult u een load balancer definiëren die voor deze NGINX-servers zal staan en deze configureren om in een round-robin-modus te balanceren.
Stap 6 — Definiëren van een Load Balancer
In deze stap zult u een DigitalOcean Load Balancer definiëren door een instantie van de digitalocean_loadbalancer-resource te definiëren.
Nog steeds in main.ts, voeg de volgende definitie voor een load balancer toe aan het einde van de constructor van MyStack:
Het argument forwardingRule vertelt de load balancer om HTTP-verzoeken op poort 80 te beluisteren en ze door te sturen naar elk van de Droplets op poort 80.
De dropletIds specificeren de Droplets waarnaar de load balancer verzoeken zal doorsturen. Het neemt een getal, maar de waarde van droplet.id is een string. Daarom heb je de Fn.tonumber Terraform functie gebruikt om de stringwaarde van Droplet ID naar een getal om te zetten.
Opmerking: Je hebt hier de Fn.tonumber Terraform functie gebruikt in plaats van de JavaScript-native parseInt omdat de waarde van droplet.id onbekend is totdat de Droplet is aangemaakt. Terraform functies zijn ontworpen om te werken met onbekende runtime waarden voordat Terraform een configuratie toepast.
Sla het bestand op en sluit het.
Je hebt nu twee Droplets en een load balancer gedefinieerd die ervoor staan. Jouw main.ts zou er nu ongeveer zo uit moeten zien:
In de volgende stap zul je de cdktf CLI-tool gebruiken om je hele CDKTF-project te activeren.
Stap 7 — Het Voorzien van Jouw Infrastructuur
In deze stap zul je de cdktf CLI-tool gebruiken om de Droplets en load balancers te voorzien die je in de vorige stappen hebt gedefinieerd.
Zorg ervoor dat je je in de infra/ map bevindt en dat je de DIGITALOCEAN_ACCESS_TOKEN omgevingsvariabele hebt ingesteld voor je terminalsessie, voer vervolgens het cdktf deploy commando uit:
Je zou een uitvoer moeten zien die vergelijkbaar is met het volgende:
Outputinfra Initializing the backend...
infra Initializing provider plugins...
infra - Reusing previous version of digitalocean/digitalocean from the dependency lock file
infra - Using previously-installed digitalocean/digitalocean v2.19.0
infra Terraform has been successfully initialized!
infra Terraform used the selected providers to generate the following execution
plan. Resource actions are indicated with the following symbols:
+ create
Terraform will perform the following actions:
infra # digitalocean_droplet.bar (bar) will be created
+ resource "digitalocean_droplet" "bar" {
+ backups = false
+ created_at = (known after apply)
+ disk = (known after apply)
+ graceful_shutdown = false
+ id = (known after apply)
+ image = "ubuntu-20-04-x64"
+ ipv4_address = (known after apply)
+ ipv4_address_private = (known after apply)
+ ipv6 = false
+ ipv6_address = (known after apply)
+ locked = (known after apply)
+ memory = (known after apply)
+ monitoring = false
+ name = "bar"
+ price_hourly = (known after apply)
+ price_monthly = (known after apply)
+ private_networking = (known after apply)
+ region = "lon1"
+ resize_disk = true
+ size = "s-1vcpu-1gb"
+ ssh_keys = [
+ "34377800",
]
+ status = (known after apply)
+ urn = (known after apply)
+ user_data = "f9b1d9796d069fe504ce0d89439b6b664b14b1a1"
+ vcpus = (known after apply)
+ volume_ids = (known after apply)
+ vpc_uuid = (known after apply)
}
# digitalocean_droplet.foo (foo) zal worden aangemaakt
+ resource "digitalocean_droplet" "foo" {
+ backups = false
+ created_at = (known after apply)
+ disk = (known after apply)
+ graceful_shutdown = false
+ id = (known after apply)
+ image = "ubuntu-20-04-x64"
+ ipv4_address = (known after apply)
+ ipv4_address_private = (known after apply)
+ ipv6 = false
+ ipv6_address = (known after apply)
+ locked = (known after apply)
+ memory = (known after apply)
+ monitoring = false
+ name = "foo"
+ price_hourly = (known after apply)
+ price_monthly = (known after apply)
+ private_networking = (known after apply)
+ region = "lon1"
+ resize_disk = true
+ size = "s-1vcpu-1gb"
+ ssh_keys = [
+ "34377800",
]
+ status = (known after apply)
+ urn = (known after apply)
+ user_data = "f9b1d9796d069fe504ce0d89439b6b664b14b1a1"
+ vcpus = (known after apply)
+ volume_ids = (known after apply)
+ vpc_uuid = (known after apply)
}
# digitalocean_loadbalancer.lb (lb) zal worden aangemaakt
+ resource "digitalocean_loadbalancer" "lb" {
+ algorithm = "round_robin"
+ disable_lets_encrypt_dns_records = false
+ droplet_ids = (known after apply)
+ enable_backend_keepalive = false
+ enable_proxy_protocol = false
+ id = (known after apply)
+ ip = (known after apply)
+ name = "default"
+ redirect_http_to_https = false
+ region = "lon1"
+ size_unit = (known after apply)
+ status = (known after apply)
+ urn = (known after apply)
+ vpc_uuid = (known after apply)
+ forwarding_rule {
+ certificate_id = (known after apply)
+ certificate_name = (known after apply)
+ entry_port = 80
+ entry_protocol = "http"
+ target_port = 80
+ target_protocol = "http"
+ tls_passthrough = false
}
+ healthcheck {
+ check_interval_seconds = (known after apply)
+ healthy_threshold = (known after apply)
+ path = (known after apply)
+ port = (known after apply)
+ protocol = (known after apply)
+ response_timeout_seconds = (known after apply)
+ unhealthy_threshold = (known after apply)
}
+ sticky_sessions {
+ cookie_name = (known after apply)
+ cookie_ttl_seconds = (known after apply)
+ type = (known after apply)
}
}
Plan: 3 to add, 0 to change, 0 to destroy.
─────────────────────────────────────────────────────────────────────────────
Saved the plan to: plan
To perform exactly these actions, run the following command to apply:
terraform apply "plan"
Please review the diff output above for infra
❯ Approve Applies the changes outlined in the plan.
Dismiss
Stop
Opmerking: CDKTF wordt nog steeds ontwikkeld, en de uitvoer kan verschillen van wat hierboven wordt getoond.
Deze weergave toont alle resources en eigenschappen die cdktf van plan is te maken, bij te werken en te vernietigen. Sommige waarden, zoals het ID van een Droplet, zijn alleen bekend nadat de resource is voorzien. Voor die gevallen zie je (known after apply) als de eigenschapswaarde in de uitvoer.
Bekijk de lijst met resources om er zeker van te zijn dat dit is wat je verwacht. Gebruik vervolgens de pijltoetsen om de Goedkeuren optie te selecteren en druk op ENTER.
Je zult een uitvoer zien die vergelijkbaar is met het volgende:
Outputinfra digitalocean_droplet.foo (foo): Creating...
digitalocean_droplet.bar (bar): Creating...
infra digitalocean_droplet.bar (bar): Still creating... [10s elapsed]
infra digitalocean_droplet.foo (foo): Still creating... [10s elapsed]
1 Stack deploying 0 Stacks done 0 Stacks waiting
Deze uitvoer vertelt je dat cdktf communiceert met de DigitalOcean API om de Droplet te maken. cdktf maakt eerst de Droplets omdat de load balancer afhankelijk is van het ID van de Droplet, dat onbekend is totdat de Droplets zijn voorzien.
Het maken van een Droplet duurt meestal minder dan een minuut. Zodra de Droplets zijn voorzien, gaat cdktf verder met het maken van de load balancer.
Outputinfra digitalocean_droplet.bar (bar): Creation complete after 54s [id=298041598]
infra digitalocean_droplet.foo (foo): Creation complete after 55s [id=298041600]
infra digitalocean_loadbalancer.lb (lb): Creating...
infra digitalocean_loadbalancer.lb (lb): Still creating... [10s elapsed]
De load balancer kan langer duren. Nadat de load balancer is aangemaakt, ziet u een samenvatting die aangeeft dat de stack succesvol is ingezet.
Outputinfra digitalocean_loadbalancer.lb (lb): Still creating... [1m30s elapsed]
infra digitalocean_loadbalancer.lb (lb): Creation complete after 1m32s [id=4f9ae2b7-b649-4fb4-beed-96b95bb72dd1]
infra
Apply complete! Resources: 3 added, 0 changed, 0 destroyed.
No outputs found.
U kunt nu de DigitalOcean-console bezoeken, waar u één load balancer met de naam standaard en twee gezonde Droplets met de namen foo en bar kunt zien, die elk dienen als een doelwit voor de load balancer.
U kunt testen of NGINX draait en inhoud correct serveert door het IP-adres van elke Droplet te bezoeken. U zou tekst moeten zien die vergelijkbaar is met het volgende:
Droplet: bar, IP Address: droplet_ip
Als u die tekstreeks niet ziet of de server niet reageert, controleer dan of de door u opgegeven gebruikersgegevens correct zijn en of er geen tekens (inclusief nieuwe regels) voorafgaan aan de shebang (#!). U kunt ook SSH gebruiken om in te loggen op de Droplet met uw SSH-privésleutel en de uitvoerlogs die door CloudInit zijn gegenereerd, controleren op /var/log/cloud-init-output.log:
Zodra u heeft bevestigd dat de Droplets actief zijn en inhoud serveren, kunt u beginnen met het testen van de load balancer. U doet dit door een paar verzoeken te sturen.
Voer de volgende opdracht uit vanaf uw terminal om tien verzoeken naar de load balancer te sturen:
U zou uitvoer moeten zien die vergelijkbaar is met het volgende, hoewel de IP-adressen die worden getoond anders zullen zijn:
OutputDroplet: foo, IP Address: droplet_foo_ip
Droplet: bar, IP Address: droplet_bar_ip
Droplet: foo, IP Address: droplet_foo_ip
Droplet: bar, IP Address: droplet_bar_ip
Droplet: bar, IP Address: droplet_bar_ip
Droplet: foo, IP Address: droplet_foo_ip
Droplet: bar, IP Address: droplet_bar_ip
Droplet: foo, IP Address: droplet_foo_ip
Droplet: bar, IP Address: droplet_bar_ip
Droplet: foo, IP Address: droplet_foo_ip
Het laat zien dat verzoeken naar de load balancer vijf keer naar elke Droplet zijn doorgestuurd, wat aangeeft dat de load balancer werkt.
Opmerking: De load balancer balanceert niet altijd perfect tussen de twee Droplets; u kunt vinden dat vier verzoeken naar de ene Droplet zijn gestuurd en zes naar de andere. Dit gedrag is normaal.
In deze stap hebt u cdktf gebruikt om uw resources te voorzien, en vervolgens hebt u de IP-adressen van uw Droplets en load balancer ontdekt via de DigitalOcean-console. Vervolgens hebt u verzoeken gestuurd naar elke Droplet en load balancer om te bevestigen dat ze werken.
In de volgende stap zult u de IP-adressen van de Droplets en load balancer verkrijgen zonder in te loggen op de DigitalOcean-console.
Stap 8 — Informatie Uitvoeren
In de vorige stap moest u inloggen op de DigitalOcean Console om de IP-adressen van uw Droplet en load balancer te verkrijgen. In deze stap zult u uw code iets aanpassen zodat deze informatie wordt afgedrukt in de output van het cdktf deploy-commando, waardoor u een reis naar de console bespaart.
Terraform slaat de configuratie en status van zijn beheerde resources op in state-bestanden. Voor uw infra-stack kan het state-bestand worden gevonden op infra/terraform.infra.tfstate. U kunt de IP-adressen van de Droplets en load balancer vinden in dit state-bestand.
Maar het doorzoeken van een groot bestand kan onhandig zijn. CDKTF biedt de TerraformOutput-constructie, die u kunt gebruiken om variabelen uit te voeren en ze beschikbaar te maken buiten de stack. Alle uitvoer wordt afgedrukt in stdout nadat cdktf deploy is uitgevoerd. Het uitvoeren van cdktf output kan ook op elk moment uitvoer afdrukken.
Let op: Hoewel je in deze handleiding alleen uitvoer gebruikt om informatie naar de console te printen, komt zijn echte kracht voort uit stacks die uitvoer van andere stacks gebruiken als invoer, een functie die bekend staat als cross-stack referenties.
Update het main.ts bestand om de uitvoer van de IP-adressen van de load balancer en Droplets op te nemen:
Sla het bestand op en sluit het.
Voer cdktf deploy uit om de wijziging te actualiseren:
Binnen de uitvoer zou je iets soortgelijks moeten zien als het volgende:
Output─────────────────────────────────────────────────────────────────────────────
Changes to Outputs:
+ droplet0IP = "droplet_foo_ip"
+ droplet1IP = "droplet_bar_ip"
+ loadBalancerIP = "load_balancer_ip"
You can apply this plan to save these new output values to the Terraform
state, without changing any real infrastructure.
─────────────────────────────────────────────────────────────────────────────
Deze uitvoer vertelt je dat er geen infrastructuurwijzigingen zullen worden doorgevoerd, alleen wat wordt uitvoerd vanuit de stack.
Gebruik de pijltoetsen om Goedkeuren te selecteren, en druk vervolgens op ENTER. Aan het einde van de terminaluitvoer zou je iets soortgelijks moeten zien als:
Outputinfra
droplet0IP = droplet_foo_ip
droplet1IP = droplet_bar_ip
loadBalancerIP = load_balancer_ip
Vanaf nu wordt telkens wanneer je cdktf deploy of cdktf output uitvoert, het IP-adres van de Droplets en de load balancers afgedrukt in de terminaluitvoer, waardoor het niet nodig is om die informatie vanuit de DigitalOcean-console te openen.
Je hebt nu twee Droplets en een load balancer voorzien en bevestigd dat ze werken. Je kunt het CDKTF-project dat je hebt ontwikkeld gebruiken als basis om meer geavanceerde infrastructuur te definiëren (je kunt een referentie-implementatie vinden op do-community / digitalocean-cdktf-typescript).
De bronnen die in deze tutorial zijn voorzien, zullen kosten met zich meebrengen. Als u niet van plan bent de gecreëerde infrastructuur te gebruiken, moet u deze vernietigen. In de volgende en laatste stap zult u het project opruimen door de bronnen die in deze tutorial zijn gemaakt, te vernietigen.
Stap 9 — Uw Infrastructuur Vernietigen
In deze stap zult u alle bronnen verwijderen die in deze tutorial zijn gemaakt.
Nog steeds binnen de infra/ directory, voer cdktf destroy uit:
U zou output moeten zien die vergelijkbaar is met het volgende:
Outputinfra Initializing the backend...
infra Initializing provider plugins...
infra - Reusing previous version of digitalocean/digitalocean from the dependency lock file
infra - Using previously-installed digitalocean/digitalocean v2.19.0
infra Terraform has been successfully initialized!
infra digitalocean_droplet.bar (bar): Refreshing state... [id=298041598]
digitalocean_droplet.foo (foo): Refreshing state... [id=298041600]
infra digitalocean_loadbalancer.lb (lb): Refreshing state... [id=4f9ae2b7-b649-4fb4-beed-96b95bb72dd1]
infra Terraform used the selected providers to generate the following execution
plan. Resource actions are indicated with the following symbols:
- destroy
Terraform will perform the following actions:
infra # digitalocean_droplet.bar (bar) will be destroyed
- resource "digitalocean_droplet" "bar" {
- backups = false -> null
- created_at = "2022-05-02T10:04:16Z" -> null
- disk = 25 -> null
- graceful_shutdown = false -> null
- id = "298041598" -> null
- image = "ubuntu-20-04-x64" -> null
- ipv4_address = "droplet_bar_public_ip" -> null
- ipv4_address_private = "droplet_bar_private_ip" -> null
- ipv6 = false -> null
- locked = false -> null
- memory = 1024 -> null
- monitoring = false -> null
- name = "bar" -> null
- price_hourly = 0.00744 -> null
- price_monthly = 5 -> null
- private_networking = true -> null
- region = "lon1" -> null
- resize_disk = true -> null
- size = "s-1vcpu-1gb" -> null
- ssh_keys = [
- "34377800",
] -> null
- status = "active" -> null
- tags = [] -> null
- urn = "do:droplet:298041598" -> null
- user_data = "f9b1d9796d069fe504ce0d89439b6b664b14b1a1" -> null
- vcpus = 1 -> null
- volume_ids = [] -> null
- vpc_uuid = "bed80b32-dc82-11e8-83ec-3cfdfea9f3f0" -> null
}
# digitalocean_droplet.foo (foo) zal vernietigd worden
- resource "digitalocean_droplet" "foo" {
- backups = false -> null
- created_at = "2022-05-02T10:04:16Z" -> null
- disk = 25 -> null
- graceful_shutdown = false -> null
- id = "298041600" -> null
- image = "ubuntu-20-04-x64" -> null
- ipv4_address = "droplet_foo_public_ip" -> null
- ipv4_address_private = "droplet_foo_private_ip" -> null
- ipv6 = false -> null
- locked = false -> null
- memory = 1024 -> null
- monitoring = false -> null
- name = "foo" -> null
- price_hourly = 0.00744 -> null
- price_monthly = 5 -> null
- private_networking = true -> null
- region = "lon1" -> null
- resize_disk = true -> null
- size = "s-1vcpu-1gb" -> null
- ssh_keys = [
- "34377800",
] -> null
- status = "active" -> null
- tags = [] -> null
- urn = "do:droplet:298041600" -> null
- user_data = "f9b1d9796d069fe504ce0d89439b6b664b14b1a1" -> null
- vcpus = 1 -> null
- volume_ids = [] -> null
- vpc_uuid = "bed80b32-dc82-11e8-83ec-3cfdfea9f3f0" -> null
}
# digitalocean_loadbalancer.lb (lb) zal vernietigd worden
- resource "digitalocean_loadbalancer" "lb" {
- algorithm = "round_robin" -> null
- disable_lets_encrypt_dns_records = false -> null
- droplet_ids = [
- 298041598,
- 298041600,
] -> null
- enable_backend_keepalive = false -> null
- enable_proxy_protocol = false -> null
- id = "4f9ae2b7-b649-4fb4-beed-96b95bb72dd1" -> null
- ip = "load_balancer_ip" -> null
- name = "default" -> null
- redirect_http_to_https = false -> null
- region = "lon1" -> null
- size_unit = 1 -> null
- status = "active" -> null
- urn = "do:loadbalancer:4f9ae2b7-b649-4fb4-beed-96b95bb72dd1" -> null
- vpc_uuid = "bed80b32-dc82-11e8-83ec-3cfdfea9f3f0" -> null
- forwarding_rule {
- entry_port = 80 -> null
- entry_protocol = "http" -> nul
infra l
- target_port = 80 -> null
- target_protocol = "http" -> null
- tls_passthrough = false -> null
}
- healthcheck {
- check_interval_seconds = 10 -> null
- healthy_threshold = 5 -> null
- path = "/" -> null
- port = 80 -> null
- protocol = "http" -> null
- response_timeout_seconds = 5 -> null
- unhealthy_threshold = 3 -> null
}
- sticky_sessions {
- cookie_ttl_seconds = 0 -> null
- type = "none" -> null
}
}
Plan: 0 to add, 0 to change, 3 to destroy.
─────────────────────────────────────────────────────────────────────────────
Saved the plan to: plan
To perform exactly these actions, run the following command to apply:
terraform apply "plan"
Please review the diff output above for infra
❯ Approve Applies the changes outlined in the plan.
Dismiss
Stop
Deze keer, in plaats van een + naast elke bron te tonen, toont het een -, wat aangeeft dat CDKTF van plan is de bron te vernietigen. Bekijk de voorgestelde wijzigingen, gebruik vervolgens de pijltoetsen om Goedkeuren te selecteren en druk op ENTER. De DigitalOcean-provider zal nu communiceren met de DigitalOcean API om de bronnen te vernietigen.
Outputinfra digitalocean_loadbalancer.lb (lb): Destroying... [id=4f9ae2b7-b649-4fb4-beed-96b95bb72dd1]
infra digitalocean_loadbalancer.lb (lb): Destruction complete after 1s
infra digitalocean_droplet.bar (bar): Destroying... [id=298041598]
digitalocean_droplet.foo (foo): Destroying... [id=298041600]
De load balancer werd eerst verwijderd omdat deze geen afhankelijkheden heeft (geen andere bronnen verwijzen naar de load balancer in hun invoer). Omdat de load balancer naar de Droplets verwijst, kunnen ze pas worden vernietigd nadat de load balancer is vernietigd.
Nadat de bronnen zijn vernietigd, ziet u de volgende regel afgedrukt in de output:
OutputDestroy complete! Resources: 3 destroyed.
Conclusie
In deze tutorial heb je CDKTF gebruikt om een load-balanced webpagina te voorzien en te vernietigen, bestaande uit twee DigitalOcean Droplets die NGINX-servers draaien, geserveerd achter een load balancer. Je hebt ook informatie over de resources op de terminal uitvoerd.
CDKTF is een abstractielaag boven Terraform. Een goed begrip van Terraform is nuttig om CDKTF te begrijpen. Als je meer wilt weten over Terraform, kun je de serie Hoe Infrastructure te beheren met Terraform lezen, die Terraform grondig behandelt.
Je kunt ook de officiële CDK for Terraform-documentatie en handleidingen bekijken om meer te weten te komen over CDKTF.