Mylab1 - itnett/FTD02H-N GitHub Wiki

For å starte dette prosjektet med en solid grunnlag, la oss bryte det ned i trinn og begynne med de grunnleggende konseptene og de første nødvendige stegene. Vi skal også utvikle en low-level design (LLD) og high-level design (HLD) for prosjektet.

Grunnleggende Konsepter

1. Infrastructure as Code (IaC): Bruke verktøy som Terraform for å definere og provisionere infrastruktur på en deklarativ måte.
2. Configuration Management: Bruke verktøy som Ansible for å administrere konfigurasjonen av maskiner og applikasjoner.
3. Virtualisering: Bruke VirtualBox for å opprette og administrere virtuelle maskiner lokalt.
4. Containerization: Bruke Docker for å pakke applikasjoner i lette containere som kan kjøres hvor som helst.
5. Kubernetes: Bruke Minikube for å sette opp en enkel-node Kubernetes-klynge for utvikling og testing.
6. Continuous Integration/Continuous Deployment (CI/CD): Automatisere bygg, testing og deploy av applikasjoner.

Trinn 1: Forberedelse

Forutsetninger

• Windows 11 laptop
• Admin-rettigheter på maskinen

Nødvendig programvare

• VirtualBox
• Docker Desktop
• Terraform
• Ansible
• Minikube
• Git (for versjonskontroll)

Installasjon og Konfigurasjon

Steg 1: Installere VirtualBox

1. Last ned VirtualBox fra VirtualBox nedlastingssiden.
2. Følg instruksjonene for å installere VirtualBox på din Windows 11 laptop.

Steg 2: Installere Docker Desktop

1. Last ned Docker Desktop fra Docker nedlastingssiden.
2. Følg instruksjonene for å installere Docker Desktop på din Windows 11 laptop.

Steg 3: Installere Terraform

1. Last ned Terraform fra Terraform nedlastingssiden.
2. Pakk ut zip-filen og plasser terraform.exe i en katalog som er inkludert i din PATH-miljøvariabel.

Steg 4: Installere Ansible på WSL (Windows Subsystem for Linux)

1. Åpne PowerShell som administrator og installer WSL:

   wsl --install
   

2. Installer Ubuntu fra Microsoft Store.
3. Åpne Ubuntu-terminalen og installer Ansible:

   sudo apt update
   sudo apt install ansible
   

Steg 5: Installere Minikube

1. Last ned Minikube fra Minikube nedlastingssiden.
2. Følg instruksjonene for å installere Minikube på din Windows 11 laptop.

Low-Level Design (LLD)

Infrastruktur Komponenter

1. Windows 11 Laptop: Vertsmaskin for alle verktøyene.
2. VirtualBox: Administrasjon av virtuelle maskiner.
3. Docker Desktop: Administrasjon av containere.
4. WSL med Ubuntu: Kjøre Ansible for konfigurasjonsadministrasjon.
5. Minikube: Lokal Kubernetes-klynge for utvikling og testing.
6. Terraform: Infrastruktur som kode for å administrere VirtualBox og Docker.
7. Ansible: Konfigurasjonsadministrasjon for VM-er og containere.

Nettverkskonfigurasjon

• Host-Only Adapter: Brukes av VirtualBox VM-er for intern nettverkskommunikasjon.
• Bridged Adapter: Brukes av VirtualBox VM-er for ekstern nettverkskommunikasjon.
• Docker Bridge Network: Standard nettverksmodus for Docker containere.

High-Level Design (HLD)

Arkitekturdiagram

+-------------------------------------------------+
| Windows 11 Laptop                               |
|                                                 |
| +-------------------+   +-------------------+   |
| | VirtualBox        |   | Docker Desktop    |   |
| |                   |   |                   |   |
| | +---------------+ |   | +--------------+  |   |
| | | Ubuntu VM     | |   | | Nginx Container|  |   |
| | +---------------+ |   | +--------------+  |   |
| |                   |   |                   |   |
| +-------------------+   +-------------------+   |
|                                                 |
| +---------------------------------------------+ |
| | WSL with Ubuntu                             | |
| |                                             | |
| | +--------------------+  +-----------------+ | |
| | | Ansible            |  | Terraform       | | |
| | +--------------------+  +-----------------+ | |
| |                                             | |
| +---------------------------------------------+ |
|                                                 |
| +-------------------+                           |
| | Minikube          |                           |
| +-------------------+                           |
+-------------------------------------------------+

Beskrivelse

• Windows 11 Laptop: Hovedvert for alle utviklings- og testverktøyene.
• VirtualBox: Brukt for å opprette og administrere virtuelle maskiner, inkludert Ubuntu VM-er som kjører forskjellige tjenester.
• Docker Desktop: Brukt for å administrere containere som Nginx, Python, Flask, etc.
• WSL med Ubuntu: Brukt for å kjøre Ansible for konfigurasjonsadministrasjon.
• Minikube: Brukt for å kjøre en enkel-node Kubernetes-klynge lokalt for testing og utvikling.
• Terraform: Brukt for å definere og provisionere infrastruktur som VirtualBox VM-er og Docker containere.
• Ansible: Brukt for å administrere konfigurasjonen av VM-er og containere.

Konfigurasjon og Kjøring

Opprette en Enkel VirtualBox VM med Terraform

main.tf:

provider "virtualbox" {}

resource "virtualbox_vm" "ubuntu_vm" {
  name   = "ubuntu-lab-vm"
  image  = "https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64-vagrant.box"
  cpus   = 2
  memory = "2048 mib"

  network_adapter {
    type           = "hostonly"
    host_interface = "vboxnet0"
  }

  disk {
    image = "ubuntu-lab-vm-disk.vdi"
    size  = "20 gib"
  }
}

output "vm_ip" {
  value = virtualbox_vm.ubuntu_vm.network_adapter.0.ipv4_address
}

Kjøre Ansible Playbook på Ubuntu VM

Inventory file inventory.ini:

[all]
<VM_IP_ADDRESS> ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/id_rsa

Ansible playbook playbook.yml:

- name: Configure Ubuntu VM
  hosts: all
  become: yes
  tasks:
    - name: Update and upgrade apt packages
      apt:
        update_cache: yes
        upgrade: dist

    - name: Install Docker
      apt:
        name: docker.io
        state: present
      notify:
        - Start Docker

  handlers:
    - name: Start Docker
      service:
        name: docker
        state: started

Kjøre Terraform og Ansible

1. Initialiser og kjør Terraform:

   terraform init
   terraform apply
   

2. Kjør Ansible playbook:

   ansible-playbook -i inventory.ini playbook.yml
   

Dette vil sette opp en enkel VM med Ubuntu, oppdatere systemet og installere Docker, som kan brukes for å kjøre containere. Denne grunnleggende infrastrukturen kan utvides for å inkludere flere VM-er, containere, og Kubernetes-klynger etter behov.

Hvis du har spørsmål eller trenger ytterligere detaljer om noe spesifikt, gi meg beskjed!

For å automatisere installasjonen og konfigurasjonen av nødvendig programvare på en Windows 11-maskin, kan vi lage PowerShell-skript som installerer og konfigurerer VirtualBox, Docker Desktop, Terraform, Ansible, Minikube, og Git. Her er en guide til hvordan dette kan gjøres.

Trinn 1: Opprett en GitHub Repository

1. Lag en ny repository på GitHub, f.eks. local-lab-setup.
2. Klon repository til din lokale maskin.

Trinn 2: Opprett PowerShell Skript for Installering

install-software.ps1

Dette skriptet vil laste ned og installere nødvendig programvare.

# Path to download installers
$downloadPath = "C:\temp"

# Create the download directory if it does not exist
if (-Not (Test-Path -Path $downloadPath)) {
    New-Item -ItemType Directory -Path $downloadPath
}

# Install Chocolatey if not installed
if (-Not (Get-Command choco -ErrorAction SilentlyContinue)) {
    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
}

# Install VirtualBox
choco install virtualbox -y

# Install Docker Desktop
choco install docker-desktop -y

# Install Terraform
choco install terraform -y

# Install Git
choco install git -y

# Install Minikube
choco install minikube -y

# Install WSL and Ubuntu
wsl --install -d Ubuntu

Write-Output "All software installed. Please restart your computer to complete the installation."

Trinn 3: Opprett Skript for Konfigurasjon av Ansible

Etter at WSL er installert og Ubuntu er konfigurert, kan vi bruke et skript for å installere og konfigurere Ansible i WSL.

configure-ansible.sh

Dette skriptet vil bli kjørt innenfor WSL for å installere Ansible.

#!/bin/bash

# Update and upgrade the system
sudo apt update && sudo apt upgrade -y

# Install Ansible
sudo apt install ansible -y

# Verify Ansible installation
ansible --version

Trinn 4: Automatisere Konfigurasjon med Terraform og Ansible

Opprett en terraform-mappe i ditt repository med følgende struktur:

terraform/
├── main.tf
├── inventory.ini
└── playbook.yml

terraform/main.tf

Dette Terraform-skriptet oppretter en enkel VirtualBox VM.

provider "virtualbox" {}

resource "virtualbox_vm" "ubuntu_vm" {
  name   = "ubuntu-lab-vm"
  image  = "https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64-vagrant.box"
  cpus   = 2
  memory = "2048 mib"

  network_adapter {
    type           = "hostonly"
    host_interface = "vboxnet0"
  }

  disk {
    image = "ubuntu-lab-vm-disk.vdi"
    size  = "20 gib"
  }
}

output "vm_ip" {
  value = virtualbox_vm.ubuntu_vm.network_adapter.0.ipv4_address
}

terraform/inventory.ini

Ansible inventory-fil som refererer til VM-en opprettet av Terraform.

[all]
<VM_IP_ADDRESS> ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/id_rsa

terraform/playbook.yml

Ansible playbook som konfigurerer Ubuntu VM.

- name: Configure Ubuntu VM
  hosts: all
  become: yes
  tasks:
    - name: Update and upgrade apt packages
      apt:
        update_cache: yes
        upgrade: dist

    - name: Install Docker
      apt:
        name: docker.io
        state: present
      notify:
        - Start Docker

  handlers:
    - name: Start Docker
      service:
        name: docker
        state: started

Trinn 5: Opprett et Hovedskript for å Kjøre Alt

setup-environment.ps1

Dette skriptet kjører installasjonsskriptet, konfigurerer Ansible, og kjører Terraform og Ansible playbook.

# Run installation script
.\install-software.ps1

# Restart computer to complete installation
Write-Output "Please restart your computer to complete the installation, then run this script again."
Start-Sleep -Seconds 5
exit

# Configure Ansible in WSL
wsl -d Ubuntu -u root -- ./configure-ansible.sh

# Navigate to terraform directory and run Terraform
cd terraform

# Initialize Terraform
terraform init

# Apply Terraform configuration
terraform apply -auto-approve

# Run Ansible playbook
ansible-playbook -i inventory.ini playbook.yml

Trinn 6: Last opp til GitHub og Kjør

1. Last opp alle skriptene og filene til ditt GitHub repository.

2. På en ny Windows 11-maskin, klon repository:

   git clone https://github.com/<your-username>/local-lab-setup.git
   cd local-lab-setup
   

3. Kjør hovedskriptet for å sette opp miljøet:

   .\setup-environment.ps1
   

Dette vil automatisk installere og konfigurere nødvendig programvare, sette opp et VirtualBox-miljø, kjøre Terraform for å opprette VM-er, og bruke Ansible for å konfigurere dem.

Hvis du har flere spørsmål eller trenger ytterligere hjelp, er det bare å si fra! For å holde alle komponentene til ditt labmiljø organisert under en enkelt rotmappe som C:\lab\mylab1, kan du strukturere katalogene slik at det er enkelt å navigere og administrere. Her er en forslag til en smart katalogstruktur og oppsett for dette:

Katalogstruktur

C:\lab\mylab1
│
├───ansible
│   ├───playbook.yml
│   ├───inventory.ini
│   └───configure-ansible.sh
│
├───docker
│   ├───Dockerfile
│   └───docker-compose.yml
│
├───terraform
│   ├───main.tf
│   └───variables.tf
│
├───vbox
│   ├───vms
│   │   └───ubuntu-lab-vm
│   │       └───... (VM files)
│   └───iso
│       └───ubuntu.iso
│
├───wsl
│   └───... (WSL related files)
│
├───scripts
│   ├───install-software.ps1
│   ├───setup-environment.ps1
│   └───other-scripts.ps1
│
└───git
    └───... (Git repositories)

Skript for Å Opprette Katalogstrukturen

Opprett et PowerShell-skript for å opprette denne katalogstrukturen og kopiere nødvendige filer:

setup-folder-structure.ps1

# Define base path
$basePath = "C:\lab\mylab1"

# Create directories
$dirs = @(
    "$basePath\ansible",
    "$basePath\docker",
    "$basePath\terraform",
    "$basePath\vbox\vms",
    "$basePath\vbox\iso",
    "$basePath\wsl",
    "$basePath\scripts",
    "$basePath\git"
)

foreach ($dir in $dirs) {
    if (-Not (Test-Path -Path $dir)) {
        New-Item -ItemType Directory -Path $dir
    }
}

Write-Output "Directory structure created."

# Copy necessary files to respective directories
Copy-Item -Path ".\install-software.ps1" -Destination "$basePath\scripts\install-software.ps1"
Copy-Item -Path ".\setup-environment.ps1" -Destination "$basePath\scripts\setup-environment.ps1"
Copy-Item -Path ".\configure-ansible.sh" -Destination "$basePath\ansible\configure-ansible.sh"
Copy-Item -Path ".\main.tf" -Destination "$basePath\terraform\main.tf"
Copy-Item -Path ".\playbook.yml" -Destination "$basePath\ansible\playbook.yml"
Copy-Item -Path ".\inventory.ini" -Destination "$basePath\ansible\inventory.ini"

Write-Output "Files copied to respective directories."

Hovedskriptet Oppdatert for Ny Katalogstruktur

setup-environment.ps1

# Define base path
$basePath = "C:\lab\mylab1"

# Run folder structure setup script
.\setup-folder-structure.ps1

# Run installation script
.\$basePath\scripts\install-software.ps1

# Restart computer to complete installation
Write-Output "Please restart your computer to complete the installation, then run this script again."
Start-Sleep -Seconds 5
exit

# Configure Ansible in WSL
wsl -d Ubuntu -u root -- ./ansible/configure-ansible.sh

# Navigate to terraform directory and run Terraform
cd $basePath\terraform

# Initialize Terraform
terraform init

# Apply Terraform configuration
terraform apply -auto-approve

# Run Ansible playbook
ansible-playbook -i $basePath\ansible\inventory.ini $basePath\ansible\playbook.yml

Oppdatert Terraform og Ansible Filer

terraform/main.tf

provider "virtualbox" {}

resource "virtualbox_vm" "ubuntu_vm" {
  name   = "ubuntu-lab-vm"
  image  = "${path.module}/../vbox/iso/ubuntu.iso"
  cpus   = 2
  memory = "2048 mib"

  network_adapter {
    type           = "hostonly"
    host_interface = "vboxnet0"
  }

  disk {
    image = "${path.module}/../vbox/vms/ubuntu-lab-vm-disk.vdi"
    size  = "20 gib"
  }
}

output "vm_ip" {
  value = virtualbox_vm.ubuntu_vm.network_adapter.0.ipv4_address
}

ansible/inventory.ini

Oppdater med riktig IP-adresse etter at Terraform har kjørt.

[all]
<VM_IP_ADDRESS> ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/id_rsa

ansible/playbook.yml

- name: Configure Ubuntu VM
  hosts: all
  become: yes
  tasks:
    - name: Update and upgrade apt packages
      apt:
        update_cache: yes
        upgrade: dist

    - name: Install Docker
      apt:
        name: docker.io
        state: present
      notify:
        - Start Docker

  handlers:
    - name: Start Docker
      service:
        name: docker
        state: started

Trinn 5: Last opp til GitHub og Kjør

1. Last opp alle skriptene og filene til ditt GitHub repository.

2. På en ny Windows 11-maskin, klon repository:

   git clone https://github.com/<your-username>/local-lab-setup.git
   cd local-lab-setup
   

3. Kjør hovedskriptet for å sette opp miljøet:

   .\scripts\setup-environment.ps1
   

Dette vil automatisk opprette katalogstrukturen, installere og konfigurere nødvendig programvare, sette opp et VirtualBox-miljø, kjøre Terraform for å opprette VM-er, og bruke Ansible for å konfigurere dem. All programvare og konfigurering vil være organisert under C:\lab\mylab1, noe som gjør det enkelt å administrere og flytte miljøet mellom ulike maskiner.

Hvis du har flere spørsmål eller trenger ytterligere hjelp, er det bare å si fra!

Terraform er et verktøy for å bygge, endre og versjonere infrastruktur på en sikker og effektiv måte. Det kan brukes til å administrere både eksisterende og populære tjenesteleverandører, samt egendefinerte in-house-løsninger. Her er en enkel guide for å komme i gang med Terraform på en Windows 11-maskin.

1. Installer Terraform

Steg 1: Last ned Terraform

• Gå til den offisielle Terraform-nedlastingssiden: Terraform Downloads
• Velg Windows og last ned zip-filen.

Steg 2: Installer Terraform

• Pakk ut zip-filen og plasser terraform.exe i en katalog som er inkludert i din PATH-miljøvariabel. For eksempel, du kan opprette en katalog som heter C:\terraform og legge denne katalogen til PATH.

2. Konfigurer Miljø

Bruk av Windows

Steg 1: Opprett en arbeidskatalog

• Lag en ny katalog hvor du vil lagre Terraform-konfigurasjonene dine. For eksempel, C:\terraform-labs.

Steg 2: Lag en hovedkonfigurasjonsfil

• Opprett en fil som heter main.tf i din arbeidskatalog. Dette vil være hovedkonfigurasjonsfilen din.

Eksempel på main.tf:

provider "aws" {
  region = "us-west-2"
}

resource "aws_instance" "example" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = {
    Name = "example-instance"
  }
}

Dette eksempelet antar at du ønsker å opprette en AWS EC2-instans. Du må ha en AWS-konto og AWS CLI konfigurert på maskinen din.

Bruk av WSL (Windows Subsystem for Linux)

Hvis du foretrekker å bruke et Linux-miljø på Windows, kan du installere WSL og bruke Ubuntu.

Steg 1: Installer WSL

• Åpne PowerShell som administrator og kjør kommandoen:

  wsl --install
  

Steg 2: Installer Ubuntu

• Etter at WSL er installert, installer Ubuntu fra Microsoft Store.

Steg 3: Installer Terraform på Ubuntu

• Åpne Ubuntu-terminalen og kjør følgende kommandoer:

  sudo apt-get update
  sudo apt-get install -y gnupg software-properties-common curl
  curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
  sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
  sudo apt-get update
  sudo apt-get install terraform
  

3. Bruk Terraform

Steg 1: Initialiser Terraform

• Naviger til katalogen der main.tf er plassert.
• Kjør kommandoen:

  terraform init
  

Steg 2: Planlegg Infrastruktur

• For å se hvilke endringer Terraform vil gjøre, kjør:

  terraform plan
  

Steg 3: Påfør Infrastruktur

• For å faktisk opprette infrastrukturen, kjør:

  terraform apply
  

4. Administrer Infrastruktur

Når infrastrukturen er opprettet, kan du bruke Terraform til å administrere og oppdatere den ved å endre main.tf-filen og kjøre terraform apply igjen. For å destruere infrastrukturen, kjør:

terraform destroy

Oppsummering

Med denne guiden har du satt opp Terraform på din Windows 11-maskin, enten direkte på Windows eller gjennom WSL med Ubuntu. Du kan nå skrive Terraform-konfigurasjoner for å opprette og administrere infrastruktur i skyer som AWS, Azure, og GCP. Dette er en kraftig måte å automatisere og versjonere infrastruktur på.

Hvis du har noen spesifikke spørsmål eller trenger hjelp med en bestemt del av prosessen, er det bare å si fra!

Ja, du kan bruke Terraform for å administrere både VirtualBox og Docker-miljøer direkte fra Windows 11 uten å først opprette et miljø i VirtualBox. Her er en enkel guide til hvordan du kan komme i gang med begge deler.

Administrere VirtualBox med Terraform

Steg 1: Installer VirtualBox og Terraform

Installer VirtualBox:

• Last ned og installer VirtualBox fra VirtualBox nedlastingssiden.

Installer Terraform:

• Følg instruksjonene fra forrige svar for å installere Terraform på Windows 11.

Steg 2: Konfigurer Terraform for VirtualBox

Eksempel main.tf for VirtualBox:

provider "virtualbox" {}

resource "virtualbox_vm" "example" {
  name   = "example-vm"
  image  = "ubuntu/bionic64"
  cpus   = 1
  memory = "512 mib"

  network_adapter {
    type           = "hostonly"
    host_interface = "vboxnet0"
  }
}

Steg 3: Initialiser og kjør Terraform

• Naviger til katalogen der main.tf er plassert.
• Initialiser Terraform:

  terraform init
  

• Planlegg infrastrukturen:

  terraform plan
  

• Påfør infrastrukturen:

  terraform apply
  

Administrere Docker med Terraform

Steg 1: Installer Docker og Terraform

Installer Docker Desktop:

• Last ned og installer Docker Desktop fra Docker nedlastingssiden.

Installer Terraform:

• Følg instruksjonene fra forrige svar for å installere Terraform på Windows 11.

Steg 2: Konfigurer Terraform for Docker

Eksempel main.tf for Docker:

provider "docker" {}

resource "docker_image" "nginx" {
  name         = "nginx:latest"
  keep_locally = false
}

resource "docker_container" "nginx" {
  image = docker_image.nginx.latest
  name  = "nginx_example"
  ports {
    internal = 80
    external = 80
  }
}

Steg 3: Initialiser og kjør Terraform

• Naviger til katalogen der main.tf er plassert.
• Initialiser Terraform:

  terraform init
  

• Planlegg infrastrukturen:

  terraform plan
  

• Påfør infrastrukturen:

  terraform apply
  

Oppsummering

Med disse trinnene kan du bruke Terraform til å administrere både VirtualBox og Docker-miljøer direkte fra Windows 11. Dette gir deg muligheten til å bygge og administrere komplekse utviklings- og testmiljøer på en enkel og automatisert måte. Hvis du har noen spesifikke spørsmål eller trenger ytterligere hjelp, er det bare å si fra!

Her er flere eksempler og fullverdige skript som du kan bruke for å bygge et labmiljø på din Windows 11-maskin ved hjelp av Terraform. Disse skriptene dekker både VirtualBox og Docker.

VirtualBox Eksempel

Forutsetninger:

• VirtualBox er installert.
• Terraform er installert.

Eksempel 1: Opprette en Ubuntu VM med VirtualBox

Opprett en katalog for ditt Terraform-prosjekt, f.eks. C:\terraform-virtualbox-lab, og opprett en fil kalt main.tf.

Innholdet i main.tf:

provider "virtualbox" {}

resource "virtualbox_vm" "ubuntu_vm" {
  name   = "ubuntu-lab-vm"
  image  = "https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64-vagrant.box"
  cpus   = 2
  memory = "2048 mib"

  network_adapter {
    type           = "hostonly"
    host_interface = "vboxnet0"
  }

  disk {
    image = "ubuntu-lab-vm-disk.vdi"
    size  = "20 gib"
  }
}

output "vm_ip" {
  value = virtualbox_vm.ubuntu_vm.network_adapter.0.ipv4_address
}

Steg for å kjøre skriptet:

1. Åpne en terminal (CMD eller PowerShell).
2. Naviger til katalogen der main.tf er plassert.
3. Kjør kommandoene:

   terraform init
   terraform apply
   

Docker Eksempel

Forutsetninger:

• Docker Desktop er installert og kjører.
• Terraform er installert.

Eksempel 2: Opprette en Nginx Container med Docker

Opprett en katalog for ditt Terraform-prosjekt, f.eks. C:\terraform-docker-lab, og opprett en fil kalt main.tf.

Innholdet i main.tf:

provider "docker" {}

resource "docker_image" "nginx" {
  name         = "nginx:latest"
  keep_locally = false
}

resource "docker_container" "nginx" {
  image = docker_image.nginx.latest
  name  = "nginx-lab-container"
  ports {
    internal = 80
    external = 8080
  }
}

output "nginx_url" {
  value = "http://localhost:8080"
}

Steg for å kjøre skriptet:

1. Åpne en terminal (CMD eller PowerShell).
2. Naviger til katalogen der main.tf er plassert.
3. Kjør kommandoene:

   terraform init
   terraform apply
   

Fullverdig Eksempel: VirtualBox med Multiple VMs

Her er et mer komplekst eksempel der vi oppretter flere VM-er med VirtualBox.

Forutsetninger:

• VirtualBox er installert.
• Terraform er installert.

Eksempel 3: Opprette flere VM-er med VirtualBox

Opprett en katalog for ditt Terraform-prosjekt, f.eks. C:\terraform-multi-vm-lab, og opprett en fil kalt main.tf.

Innholdet i main.tf:

provider "virtualbox" {}

variable "vm_count" {
  default = 3
}

resource "virtualbox_vm" "lab_vm" {
  count  = var.vm_count
  name   = "lab-vm-${count.index}"
  image  = "https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64-vagrant.box"
  cpus   = 1
  memory = "1024 mib"

  network_adapter {
    type           = "hostonly"
    host_interface = "vboxnet0"
  }

  disk {
    image = "lab-vm-disk-${count.index}.vdi"
    size  = "10 gib"
  }
}

output "vm_ips" {
  value = [for i in virtualbox_vm.lab_vm: i.network_adapter[0].ipv4_address]
}

Steg for å kjøre skriptet:

1. Åpne en terminal (CMD eller PowerShell).
2. Naviger til katalogen der main.tf er plassert.
3. Kjør kommandoene:

   terraform init
   terraform apply
   

Oppsummering

Disse eksemplene viser hvordan du kan bruke Terraform til å opprette og administrere labmiljøer på Windows 11, både med VirtualBox og Docker. Du kan utvide disse skriptene for å inkludere flere ressurser og konfigurasjoner etter behov. Hvis du har spørsmål eller trenger mer hjelp med spesifikke konfigurasjoner, er det bare å si fra!

Ja, du kan opprette et Kubernetes-miljø på din egen Windows 11 laptop ved å bruke Terraform, men du vil sannsynligvis trenge å bruke en Kubernetes-distribusjon som er enkel å sette opp på lokal maskinvare. For Windows 11 er det vanlig å bruke Minikube, som kan kjøre en enkelt-node Kubernetes-klynge lokalt ved hjelp av VirtualBox eller Docker.

Her er trinnene for å sette opp et Minikube Kubernetes-miljø med Terraform:

Forutsetninger

1. Installer VirtualBox eller Docker Desktop:

   • VirtualBox nedlasting
   • Docker Desktop nedlasting

2. Installer Minikube:

   • Last ned og installer Minikube fra Minikube nedlasting.

3. Installer Terraform:

   • Følg instruksjonene fra tidligere svar for å installere Terraform på Windows 11.

Konfigurer Terraform for Minikube

Du kan bruke Terraform til å automatisere oppsettet av Minikube. Her er et eksempel på et Terraform-skript som konfigurerer Minikube ved hjelp av VirtualBox som driver.

Steg 1: Opprett en katalog for Terraform-prosjektet

Opprett en katalog for prosjektet, f.eks. C:\terraform-minikube-lab, og opprett en fil kalt main.tf.

Steg 2: Opprett main.tf

provider "local" {
  version = "~> 2.0"
}

resource "null_resource" "minikube" {
  provisioner "local-exec" {
    command = <<EOT
      minikube start --driver=virtualbox
    EOT
  }

  provisioner "local-exec" {
    when    = destroy
    command = "minikube delete"
  }
}

output "minikube_status" {
  value = "Minikube cluster is running. Use 'kubectl get nodes' to check the status."
}

Dette skriptet bruker local-exec provisioners for å kjøre Minikube-kommandoene direkte på ditt lokale system.

Steg 3: Initialiser og kjør Terraform

1. Åpne en terminal (CMD eller PowerShell).
2. Naviger til katalogen der main.tf er plassert.
3. Kjør kommandoene:

   terraform init
   terraform apply
   

Kontrollere Kubernetes Klyngen

Når Terraform-skriptet har kjørt, vil Minikube-klyngen være oppe og kjøre. Du kan bruke kubectl til å samhandle med klyngen. Minikube leverer kubectl sammen med sin installasjon.

Eksempel på kommandoer:

• For å se nodene i klyngen:

  kubectl get nodes
  

• For å se tilgjengelige podder:

  kubectl get pods --all-namespaces
  

Oppsummering

Dette oppsettet viser hvordan du kan bruke Terraform til å automatisere opprettelsen av et lokalt Kubernetes-miljø ved hjelp av Minikube på Windows 11. Dette er en fin måte å sette opp en lokal Kubernetes-klynge for testing og utvikling uten behov for en sky-tjenesteleverandør.

Hvis du har ytterligere spørsmål eller trenger hjelp med spesifikke konfigurasjoner, er det bare å si fra!

Det høres ut som du vil bygge et omfattende og fleksibelt labmiljø på din Windows 11 laptop. Dette miljøet skal kunne administrere alt fra VirtualBox VM-er til Docker-kontainere, og inkludere muligheter for CI/CD med Terraform og Ansible. La oss gå gjennom hva vi har dekket så langt, og legge til de ekstra mulighetene som trengs for ditt scenario.

1. Oppsummering av det vi har dekket

VirtualBox med Terraform

• Oppretting av Ubuntu VM med Terraform og VirtualBox.
• Oppretting av flere VM-er med Terraform og VirtualBox.

Docker med Terraform

• Oppretting av en Nginx-container med Terraform og Docker.

Kubernetes med Terraform

• Oppretting av et lokalt Kubernetes-miljø med Minikube og Terraform.

2. Ytterligere Muligheter med Terraform og Ansible

WSL (Windows Subsystem for Linux) med Terraform

• Installere og administrere WSL med Terraform.
• Oppretting av Linux-miljøer i WSL for utvikling og testing.

VirtualBox med Ansible

• Bruke Ansible for å konfigurere og administrere VirtualBox VM-er.
• Automatisere installasjon og konfigurasjon av applikasjoner på VM-ene.

Kjøre Docker i VirtualBox VM-er

• Opprette og administrere Docker-kontainere inne i VirtualBox VM-er med Terraform og Ansible.

3. Detaljert Plan og Skript

1. Installere og Konfigurere WSL med Terraform

main.tf:

provider "local" {
  version = "~> 2.0"
}

resource "null_resource" "install_wsl" {
  provisioner "local-exec" {
    command = <<EOT
      wsl --install
    EOT
  }

  provisioner "local-exec" {
    when    = destroy
    command = <<EOT
      wsl --unregister Ubuntu
    EOT
  }
}

output "wsl_status" {
  value = "WSL is installed. You can use 'wsl' command to start using it."
}

2. Opprette og Konfigurere VM-er med Terraform og Ansible

Terraform main.tf:

provider "virtualbox" {}

resource "virtualbox_vm" "ubuntu_vm" {
  name   = "ubuntu-vm"
  image  = "https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64-vagrant.box"
  cpus   = 2
  memory = "2048 mib"

  network_adapter {
    type           = "hostonly"
    host_interface = "vboxnet0"
  }

  disk {
    image = "ubuntu-vm-disk.vdi"
    size  = "20 gib"
  }
}

output "vm_ip" {
  value = virtualbox_vm.ubuntu_vm.network_adapter.0.ipv4_address
}

Ansible playbook playbook.yml:

- name: Configure Ubuntu VM
  hosts: all
  become: yes
  tasks:
    - name: Update and upgrade apt packages
      apt:
        update_cache: yes
        upgrade: dist

    - name: Install Docker
      apt:
        name: docker.io
        state: present
      notify:
        - Start Docker

  handlers:
    - name: Start Docker
      service:
        name: docker
        state: started

Inventory file inventory.ini:

[all]
<VM_IP_ADDRESS> ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/id_rsa

3. Bruke Terraform for Docker-in-Docker Setup

Terraform main.tf:

provider "docker" {}

resource "docker_image" "nginx" {
  name         = "nginx:latest"
  keep_locally = false
}

resource "docker_container" "nginx" {
  image = docker_image.nginx.latest
  name  = "nginx-lab-container"
  ports {
    internal = 80
    external = 8080
  }
}

output "nginx_url" {
  value = "http://localhost:8080"
}

4. CI/CD Pipeline med Terraform og Ansible

For å automatisere hele prosessen med CI/CD, kan du sette opp et GitLab CI/CD pipeline eller bruke GitHub Actions for å kjøre Terraform og Ansible.

Eksempel på .gitlab-ci.yml:

stages:
  - setup
  - deploy

setup:
  script:
    - terraform init
    - terraform apply -auto-approve

deploy:
  script:
    - ansible-playbook -i inventory.ini playbook.yml

4. Etablere et Fullverdig Lokal CI/CD Miljø

1. Installasjon og konfigurasjon:

   • Installere VirtualBox og WSL.
   • Installere Docker Desktop.

2. Oppretting av miljø:

   • Bruke Terraform til å sette opp WSL.
   • Bruke Terraform til å opprette VirtualBox VM-er.
   • Bruke Ansible til å konfigurere VM-ene med nødvendige applikasjoner som Docker.

3. Administrasjon av miljø:

   • Bruke Terraform til å administrere Docker-kontainere både på verten (Windows) og innenfor VirtualBox VM-er.
   • Bruke Ansible til å konfigurere og administrere applikasjoner i Docker-kontainere.

4. Opprydning:

   • Bruke Terraform til å ødelegge WSL-installasjon og VirtualBox VM-er.
   • Fjerne Docker-kontainere og bilder med Terraform.

Dette omfattende oppsettet vil gi deg et robust og fleksibelt labmiljø hvor du kan øve på en rekke teknologier og sertifiseringer, samt utvikle og teste applikasjoner i ulike miljøer. Hvis du trenger ytterligere hjelp eller har spesifikke spørsmål, er det bare å si fra!

For å starte dette prosjektet med en solid grunnlag, la oss bryte det ned i trinn og begynne med de grunnleggende konseptene og de første nødvendige stegene. Vi skal også utvikle en low-level design (LLD) og high-level design (HLD) for prosjektet.

Grunnleggende Konsepter

1. Infrastructure as Code (IaC): Bruke verktøy som Terraform for å definere og provisionere infrastruktur på en deklarativ måte.
2. Configuration Management: Bruke verktøy som Ansible for å administrere konfigurasjonen av maskiner og applikasjoner.
3. Virtualisering: Bruke VirtualBox for å opprette og administrere virtuelle maskiner lokalt.
4. Containerization: Bruke Docker for å pakke applikasjoner i lette containere som kan kjøres hvor som helst.
5. Kubernetes: Bruke Minikube for å sette opp en enkel-node Kubernetes-klynge for utvikling og testing.
6. Continuous Integration/Continuous Deployment (CI/CD): Automatisere bygg, testing og deploy av applikasjoner.

Trinn 1: Forberedelse

Forutsetninger

• Windows 11 laptop
• Admin-rettigheter på maskinen

Nødvendig programvare

• VirtualBox
• Docker Desktop
• Terraform
• Ansible
• Minikube
• Git (for versjonskontroll)

Installasjon og Konfigurasjon

Steg 1: Installere VirtualBox

1. Last ned VirtualBox fra VirtualBox nedlastingssiden.
2. Følg instruksjonene for å installere VirtualBox på din Windows 11 laptop.

Steg 2: Installere Docker Desktop

1. Last ned Docker Desktop fra Docker nedlastingssiden.
2. Følg instruksjonene for å installere Docker Desktop på din Windows 11 laptop.

Steg 3: Installere Terraform

1. Last ned Terraform fra Terraform nedlastingssiden.
2. Pakk ut zip-filen og plasser terraform.exe i en katalog som er inkludert i din PATH-miljøvariabel.

Steg 4: Installere Ansible på WSL (Windows Subsystem for Linux)

1. Åpne PowerShell som administrator og installer WSL:

   wsl --install
   

2. Installer Ubuntu fra Microsoft Store.
3. Åpne Ubuntu-terminalen og installer Ansible:

   sudo apt update
   sudo apt install ansible
   

Steg 5: Installere Minikube

1. Last ned Minikube fra Minikube nedlastingssiden.
2. Følg instruksjonene for å installere Minikube på din Windows 11 laptop.

Low-Level Design (LLD)

Infrastruktur Komponenter

1. Windows 11 Laptop: Vertsmaskin for alle verktøyene.
2. VirtualBox: Administrasjon av virtuelle maskiner.
3. Docker Desktop: Administrasjon av containere.
4. WSL med Ubuntu: Kjøre Ansible for konfigurasjonsadministrasjon.
5. Minikube: Lokal Kubernetes-klynge for utvikling og testing.
6. Terraform: Infrastruktur som kode for å administrere VirtualBox og Docker.
7. Ansible: Konfigurasjonsadministrasjon for VM-er og containere.

Nettverkskonfigurasjon

• Host-Only Adapter: Brukes av VirtualBox VM-er for intern nettverkskommunikasjon.
• Bridged Adapter: Brukes av VirtualBox VM-er for ekstern nettverkskommunikasjon.
• Docker Bridge Network: Standard nettverksmodus for Docker containere.

High-Level Design (HLD)

Arkitekturdiagram

+-------------------------------------------------+
| Windows 11 Laptop                               |
|                                                 |
| +-------------------+   +-------------------+   |
| | VirtualBox        |   | Docker Desktop    |   |
| |                   |   |                   |   |
| | +---------------+ |   | +--------------+  |   |
| | | Ubuntu VM     | |   | | Nginx Container|  |   |
| | +---------------+ |   | +--------------+  |   |
| |                   |   |                   |   |
| +-------------------+   +-------------------+   |
|                                                 |
| +---------------------------------------------+ |
| | WSL with Ubuntu                             | |
| |                                             | |
| | +--------------------+  +-----------------+ | |
| | | Ansible            |  | Terraform       | | |
| | +--------------------+  +-----------------+ | |
| |                                             | |
| +---------------------------------------------+ |
|                                                 |
| +-------------------+                           |
| | Minikube          |                           |
| +-------------------+                           |
+-------------------------------------------------+

Beskrivelse

• Windows 11 Laptop: Hovedvert for alle utviklings- og testverktøyene.
• VirtualBox: Brukt for å opprette og administrere virtuelle maskiner, inkludert Ubuntu VM-er som kjører forskjellige tjenester.
• Docker Desktop: Brukt for å administrere containere som Nginx, Python, Flask, etc.
• WSL med Ubuntu: Brukt for å kjøre Ansible for konfigurasjonsadministrasjon.
• Minikube: Brukt for å kjøre en enkel-node Kubernetes-klynge lokalt for testing og utvikling.
• Terraform: Brukt for å definere og provisionere infrastruktur som VirtualBox VM-er og Docker containere.
• Ansible: Brukt for å administrere konfigurasjonen av VM-er og containere.

Konfigurasjon og Kjøring

Opprette en Enkel VirtualBox VM med Terraform

main.tf:

provider "virtualbox" {}

resource "virtualbox_vm" "ubuntu_vm" {
  name   = "ubuntu-lab-vm"
  image  = "https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64-vagrant.box"
  cpus   = 2
  memory = "2048 mib"

  network_adapter {
    type           = "hostonly"
    host_interface = "vboxnet0"
  }

  disk {
    image = "ubuntu-lab-vm-disk.vdi"
    size  = "20 gib"
  }
}

output "vm_ip" {
  value = virtualbox_vm.ubuntu_vm.network_adapter.0.ipv4_address
}

Kjøre Ansible Playbook på Ubuntu VM

Inventory file inventory.ini:

[all]
<VM_IP_ADDRESS> ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/id_rsa

Ansible playbook playbook.yml:

- name: Configure Ubuntu VM
  hosts: all
  become: yes
  tasks:
    - name: Update and upgrade apt packages
      apt:
        update_cache: yes
        upgrade: dist

    - name: Install Docker
      apt:
        name: docker.io
        state: present
      notify:
        - Start Docker

  handlers:
    - name: Start Docker
      service:
        name: docker
        state: started

Kjøre Terraform og Ansible

1. Initialiser og kjør Terraform:

   terraform init
   terraform apply
   

2. Kjør Ansible playbook:

   ansible-playbook -i inventory.ini playbook.yml
   

Dette vil sette opp en enkel VM med Ubuntu, oppdatere systemet og installere Docker, som kan brukes for å kjøre containere. Denne grunnleggende infrastrukturen kan utvides for å inkludere flere VM-er, containere, og Kubernetes-klynger etter behov.

Hvis du har spørsmål eller trenger ytterligere detaljer om noe spesifikt, gi meg beskjed!

For å automatisere installasjonen og konfigurasjonen av nødvendig programvare på en Windows 11-maskin, kan vi lage PowerShell-skript som installerer og konfigurerer VirtualBox, Docker Desktop, Terraform, Ansible, Minikube, og Git. Her er en guide til hvordan dette kan gjøres.

Trinn 1: Opprett en GitHub Repository

1. Lag en ny repository på GitHub, f.eks. local-lab-setup.
2. Klon repository til din lokale maskin.

Trinn 2: Opprett PowerShell Skript for Installering

install-software.ps1

Dette skriptet vil laste ned og installere nødvendig programvare.

# Path to download installers
$downloadPath = "C:\temp"

# Create the download directory if it does not exist
if (-Not (Test-Path -Path $downloadPath)) {
    New-Item -ItemType Directory -Path $downloadPath
}

# Install Chocolatey if not installed
if (-Not (Get-Command choco -ErrorAction SilentlyContinue)) {
    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
}

# Install VirtualBox
choco install virtualbox -y

# Install Docker Desktop
choco install docker-desktop -y

# Install Terraform
choco install terraform -y

# Install Git
choco install git -y

# Install Minikube
choco install minikube -y

# Install WSL and Ubuntu
wsl --install -d Ubuntu

Write-Output "All software installed. Please restart your computer to complete the installation."

Trinn 3: Opprett Skript for Konfigurasjon av Ansible

Etter at WSL er installert og Ubuntu er konfigurert, kan vi bruke et skript for å installere og konfigurere Ansible i WSL.

configure-ansible.sh

Dette skriptet vil bli kjørt innenfor WSL for å installere Ansible.

#!/bin/bash

# Update and upgrade the system
sudo apt update && sudo apt upgrade -y

# Install Ansible
sudo apt install ansible -y

# Verify Ansible installation
ansible --version

Trinn 4: Automatisere Konfigurasjon med Terraform og Ansible

Opprett en terraform-mappe i ditt repository med følgende struktur:

terraform/
├── main.tf
├── inventory.ini
└── playbook.yml

terraform/main.tf

Dette Terraform-skriptet oppretter en enkel VirtualBox VM.

provider "virtualbox" {}

resource "virtualbox_vm" "ubuntu_vm" {
  name   = "ubuntu-lab-vm"
  image  = "https://cloud-images.ubuntu.com/bionic/current/bionic-server-cloudimg-amd64-vagrant.box"
  cpus   = 2
  memory = "2048 mib"

  network_adapter {
    type           = "hostonly"
    host_interface = "vboxnet0"
  }

  disk {
    image = "ubuntu-lab-vm-disk.vdi"
    size  = "20 gib"
  }
}

output "vm_ip" {
  value = virtualbox_vm.ubuntu_vm.network_adapter.0.ipv4_address
}

terraform/inventory.ini

Ansible inventory-fil som refererer til VM-en opprettet av Terraform.

[all]
<VM_IP_ADDRESS> ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/id_rsa

terraform/playbook.yml

Ansible playbook som konfigurerer Ubuntu VM.

- name: Configure Ubuntu VM
  hosts: all
  become: yes
  tasks:
    - name: Update and upgrade apt packages
      apt:
        update_cache: yes
        upgrade: dist

    - name: Install Docker
      apt:
        name: docker.io
        state: present
      notify:
        - Start Docker

  handlers:
    - name: Start Docker
      service:
        name: docker
        state: started

Trinn 5: Opprett et Hovedskript for å Kjøre Alt

setup-environment.ps1

Dette skriptet kjører installasjonsskriptet, konfigurerer Ansible, og kjører Terraform og Ansible playbook.

# Run installation script
.\install-software.ps1

# Restart computer to complete installation
Write-Output "Please restart your computer to complete the installation, then run this script again."
Start-Sleep -Seconds 5
exit

# Configure Ansible in WSL
wsl -d Ubuntu -u root -- ./configure-ansible.sh

# Navigate to terraform directory and run Terraform
cd terraform

# Initialize Terraform
terraform init

# Apply Terraform configuration
terraform apply -auto-approve

# Run Ansible playbook
ansible-playbook -i inventory.ini playbook.yml

Trinn 6: Last opp til GitHub og Kjør

1. Last opp alle skriptene og filene til ditt GitHub repository.

2. På en ny Windows 11-maskin, klon repository:

   git clone https://github.com/<your-username>/local-lab-setup.git
   cd local-lab-setup
   

3. Kjør hovedskriptet for å sette opp miljøet:

   .\setup-environment.ps1
   

Dette vil automatisk installere og konfigurere nødvendig programvare, sette opp et VirtualBox-miljø, kjøre Terraform for å opprette VM-er, og bruke Ansible for å konfigurere dem.

Hvis du har flere spørsmål eller trenger ytterligere hjelp, er det bare å si fra!

For å holde alle komponentene til ditt labmiljø organisert under en enkelt rotmappe som C:\lab\mylab1, kan du strukturere katalogene slik at det er enkelt å navigere og administrere. Her er en forslag til en smart katalogstruktur og oppsett for dette:

Katalogstruktur

C:\lab\mylab1
│
├───ansible
│   ├───playbook.yml
│   ├───inventory.ini
│   └───configure-ansible.sh
│
├───docker
│   ├───Dockerfile
│   └───docker-compose.yml
│
├───terraform
│   ├───main.tf
│   └───variables.tf
│
├───vbox
│   ├───vms
│   │   └───ubuntu-lab-vm
│   │       └───... (VM files)
│   └───iso
│       └───ubuntu.iso
│
├───wsl
│   └───... (WSL related files)
│
├───scripts
│   ├───install-software.ps1
│   ├───setup-environment.ps1
│   └───other-scripts.ps1
│
└───git
    └───... (Git repositories)

Skript for Å Opprette Katalogstrukturen

Opprett et PowerShell-skript for å opprette denne katalogstrukturen og kopiere nødvendige filer:

setup-folder-structure.ps1

# Define base path
$basePath = "C:\lab\mylab1"

# Create directories
$dirs = @(
    "$basePath\ansible",
    "$basePath\docker",
    "$basePath\terraform",
    "$basePath\vbox\vms",
    "$basePath\vbox\iso",
    "$basePath\wsl",
    "$basePath\scripts",
    "$basePath\git"
)

foreach ($dir in $dirs) {
    if (-Not (Test-Path -Path $dir)) {
        New-Item -ItemType Directory -Path $dir
    }
}

Write-Output "Directory structure created."

# Copy necessary files to respective directories
Copy-Item -Path ".\install-software.ps1" -Destination "$basePath\scripts\install-software.ps1"
Copy-Item -Path ".\setup-environment.ps1" -Destination "$basePath\scripts\setup-environment.ps1"
Copy-Item -Path ".\configure-ansible.sh" -Destination "$basePath\ansible\configure-ansible.sh"
Copy-Item -Path ".\main.tf" -Destination "$basePath\terraform\main.tf"
Copy-Item -Path ".\playbook.yml" -Destination "$basePath\ansible\playbook.yml"
Copy-Item -Path ".\inventory.ini" -Destination "$basePath\ansible\inventory.ini"

Write-Output "Files copied to respective directories."

Hovedskriptet Oppdatert for Ny Katalogstruktur

setup-environment.ps1

# Define base path
$basePath = "C:\lab\mylab1"

# Run folder structure setup script
.\setup-folder-structure.ps1

# Run installation script
.\$basePath\scripts\install-software.ps1

# Restart computer to complete installation
Write-Output "Please restart your computer to complete the installation, then run this script again."
Start-Sleep -Seconds 5
exit

# Configure Ansible in WSL
wsl -d Ubuntu -u root -- ./ansible/configure-ansible.sh

# Navigate to terraform directory and run Terraform
cd $basePath\terraform

# Initialize Terraform
terraform init

# Apply Terraform configuration
terraform apply -auto-approve

# Run Ansible playbook
ansible-playbook -i $basePath\ansible\inventory.ini $basePath\ansible\playbook.yml

Oppdatert Terraform og Ansible Filer

terraform/main.tf

provider "virtualbox" {}

resource "virtualbox_vm" "ubuntu_vm" {
  name   = "ubuntu-lab-vm"
  image  = "${path.module}/../vbox/iso/ubuntu.iso"
  cpus   = 2
  memory = "2048 mib"

  network_adapter {
    type           = "hostonly"
    host_interface = "vboxnet0"
  }

  disk {
    image = "${path.module}/../vbox/vms/ubuntu-lab-vm-disk.vdi"
    size  = "20 gib"
  }
}

output "vm_ip" {
  value = virtualbox_vm.ubuntu_vm.network_adapter.0.ipv4_address
}

ansible/inventory.ini

Oppdater med riktig IP-adresse etter at Terraform har kjørt.

[all]
<VM_IP_ADDRESS> ansible_user=ubuntu ansible_ssh_private_key_file=~/.ssh/id_rsa

ansible/playbook.yml

- name: Configure Ubuntu VM
  hosts: all
  become: yes
  tasks:
    - name: Update and upgrade apt packages
      apt:
        update_cache: yes
        upgrade: dist

    - name: Install Docker
      apt:
        name: docker.io
        state: present
      notify:
        - Start Docker

  handlers:
    - name: Start Docker
      service:
        name: docker
        state: started

Trinn 5: Last opp til GitHub og Kjør

1. Last opp alle skriptene og filene til ditt GitHub repository.

2. På en ny Windows 11-maskin, klon repository:

   git clone https://github.com/<your-username>/local-lab-setup.git
   cd local-lab-setup
   

3. Kjør hovedskriptet for å sette opp miljøet:

   .\scripts\setup-environment.ps1
   

Dette vil automatisk opprette katalogstrukturen, installere og konfigurere nødvendig programvare, sette opp et VirtualBox-miljø, kjøre Terraform for å opprette VM-er, og bruke Ansible for å konfigurere dem. All programvare og konfigurering vil være organisert under C:\lab\mylab1, noe som gjør det enkelt å administrere og flytte miljøet mellom ulike maskiner.

Hvis du har flere spørsmål eller trenger ytterligere hjelp, er det bare å si fra!