# Remove old Docker variants
for pkg in docker.io docker-doc docker-compose podman-docker containerd runc; do sudo apt-get remove $pkg; done

# 1. Update and install dependencies
sudo apt-get update
sudo apt-get install -y \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

# 2. Add Docker’s official GPG key and set up the repo
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 3. Install Docker Engine
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# 4. Verify your install
docker run --rm hello-world

# 5. (Optional) If you want to manage Docker as a non-root user, add yourself to the docker group:
sudo usermod -aG docker $USER
newgrp docker

services:
  terraform: # The name of the service that will run Terraform.
    image: hashicorp/terraform:1.12.2
    # It sets the Docker image we want to use for our service, pin your exact version terraform --version
    volumes:
        - .:/terraform
    # Maps the current project directory to /terraform in the container.
    # Docker containers use virtualization to run in an environment that’s isolated from the host machine. As a result, containers don’t have access to the file system by default.
    # To get around this problem, we define - .:/terraform which creates volume mapping . (this is shorthand for the current project directory where the docker-compose.yml is located)
    # to /terraform inside the docker container.
    working_dir: /terraform
    # Sets the working directory inside the container.
    # It tells the Docker container to work from the /terraform directory (working directory) which we are mapping our code project to.
    # If they don't match, the container will not know where to look for the configuration files.
    network: host
    # So the container can communicate with the ProxMox server without any additional network setup.
    entrypoint: ["terraform"] # Specifies the command to run when the container starts.
    command: ["plan", "-var-file=credentials.auto.tfvars"]
    # Passes Terraform command and arguments to the container.
    # The docker compose command does not directly support Terraform's -var or -var-file flags.
    # Instead, we need to pass these arguments to the terraform command inside the container.

# Initialize providers & backend
root@myserver:~/terraform# docker compose -f docker-compose.yml run --rm terraform init --upgrade

# Expected Output:
Initializing the backend...

Initializing provider plugins...
Terraform has been successfully initialized!
You may now begin working with Terraform. Try running "terraform plan" to see any changes that are required for your infrastructure. All Terraform commands should now work.
[...]

# Preview changes
# Next, preview the changes that Terraform will make to your infrastructure:
root@myserver:~/terraform# docker compose -f docker-compose.yml run --rm terraform plan -out k8s-master.tfplan

# Expected Output:
No changes. Infrastructure is up-to-date.
# This message indicates that Terraform did not detect any differences between your configuration and the existing infrastructure, meaning no actions are needed at this time.

# If you are ready to apply the planned changes, execute the following command:
docker compose -f docker-compose.yml run --rm terraform apply "k8s-master.tfplan"

volumes:
  - .:/terraform

#!/bin/bash
# Make the script executable: chmod +x proxmox-terraform.sh
# Run the script: ./proxmox-terraform.sh

# Variables
VM_ID=207
DOCKER_COMPOSE_FILE="docker-compose.yml"
TERRAFORM_DIR="/root/terraform" # Update this path as needed

# Function to check if a VM exists
vm_exists() {
    qm status $VM_ID > /dev/null 2>&1
    return $?
}

# Remove the previously created VM if it exists
# Normally, you need to stop using Proxmox's GUI, VM, Shutdown (gracefully) or Stop.
# Sometimes, you need to stop a broken VM using: qm stop 207
if vm_exists; then
    echo "VM $VM_ID exists. Removing it..."
    qm stop $VM_ID --force > /dev/null 2>&1
    qm destroy $VM_ID --purge > /dev/null 2>&1
    echo "VM $VM_ID removed."
else
    echo "VM $VM_ID does not exist. Skipping removal."
fi

# Change to the Terraform directory
cd $TERRAFORM_DIR || { echo "Failed to change to directory $TERRAFORM_DIR"; exit 1; }

# Run Docker Compose commands
# When you are done editing the configuration files.
# Use Docker Compose to run Terraform commands in a containerized environment.
# The -f flag specifies which Docker Compose file to use, in this case, docker-compose.yml.
# The --rm flag ensures that the container is removed after the command completes.
# Initializes the Terraform environment.
echo "Running 'docker compose -f $DOCKER_COMPOSE_FILE run --rm terraform init'..."
docker compose -f $DOCKER_COMPOSE_FILE run --rm terraform init || { echo "Terraform init failed"; exit 1; }

# Generates and shows the execution plan, allowing you to see what actions Terraform will take.
echo "Running 'docker compose -f $DOCKER_COMPOSE_FILE run --rm terraform plan'..."
docker compose -f $DOCKER_COMPOSE_FILE run --rm terraform plan -out k8s-master.tfplan || { echo "Terraform plan failed"; exit 1; }

# Applies the changes to create the VM
echo "Running 'docker compose -f $DOCKER_COMPOSE_FILE run --rm terraform apply'..."
docker compose -f $DOCKER_COMPOSE_FILE run --rm terraform apply -auto-approve k8s-master.tfplan || { echo "Terraform apply failed"; exit 1; }

echo "Script completed successfully."