Instruqt

https://docs.labs.instruqt.com
Admin
Instruqt is an interactive learning platform that enables creation of hands-on labs and training...
Tokens:137,670
Snippets:1,720
Trust Score:8.9
Update:5 months ago
Show doc for...
Tokens:
Raw
### Simple Server Certificate Example

Source: https://docs.labs.instruqt.com/reference/sandbox/certificates/cert/certificateleaf

An example demonstrating how to generate a server certificate using the `certificate_leaf` resource, including the necessary CA setup.

```APIDOC
## Simple Server Certificate Example

### Description
This example illustrates the creation of a server certificate using the `certificate_leaf` resource. It includes the prerequisite step of generating a root CA using `certificate_ca`.

### HCL Configuration
```hcl
resource "certificate_ca" "root" {
  output = "./ca"
}

resource "certificate_leaf" "server" {
  ca_key  = resource.certificate_ca.root.private_key.path    # e.g., "./ca/private_key.pem"
  ca_cert = resource.certificate_ca.root.certificate.path    # e.g., "./ca/certificate.pem"
  output  = "./server-certs"

  dns_names    = ["localhost"]
  ip_addresses = ["127.0.0.1"]
}

output "server_cert_path" {
  value = resource.certificate_leaf.server.certificate.path  # e.g., "./server-certs/certificate.pem"
}
```
```

--------------------------------

### Full Task Resource with Docker Setup

Source: https://docs.labs.instruqt.com/reference/content/task

A comprehensive task resource demonstrating Docker setup, container creation, and cleanup. Includes detailed configuration for setup, check, solve, and cleanup scripts.

```hcl
resource "task" "docker_setup" {
  description      = "Complete the Docker setup"
  success_message  = "Excellent! You've completed all requirements."

  config {
    target               = resource.container.ubuntu
    user                 = "root"
    group                = "root"
    working_directory    = "/home/user"
    timeout              = "30s"
    environment = {
      PATH = "/usr/local/bin:/usr/bin:/bin"
    }
    success_exit_codes   = [0]
    failure_exit_codes   = [1, 2]

    parallel_exec {
      condition = true
      check     = false
      solve     = false
      setup     = false
      cleanup   = false
    }
  }

  condition "setup_environment" {
    description = "Set up the Docker environment"

    config {
      timeout = "60s"
    }

    setup {
      script = "scripts/task/docker_setup/setup_docker.sh"
    }

    check {
      script          = "scripts/task/docker_setup/check_docker.sh"
      failure_message = "Docker is not running correctly"
    }

    solve {
      script = "scripts/task/docker_setup/solve_docker.sh"
    }

    cleanup {
      script = "scripts/task/docker_setup/cleanup_docker.sh"
    }
  }

  condition "create_container" {
    description = "Create and run a container"

    check {
      script = "scripts/task/docker_setup/check_container.sh"

      config {
        timeout = "45s"
      }
    }

    solve {
      script = "scripts/task/docker_setup/solve_container.sh"
    }
  }
}
```

--------------------------------

### Basic Network Example

Source: https://docs.labs.instruqt.com/reference/sandbox/networking/network

Example of creating a basic network named 'backend' with a specific subnet. This is a common starting point for network setup.

```hcl
resource "network" "backend" {
  subnet = "10.0.1.0/24"
}
```

--------------------------------

### Install Migration Toolkit

Source: https://docs.labs.instruqt.com/migration/toolkit

Install the migration toolkit using Go modules or by downloading a binary release.

```bash
go install github.com/instruqt/migration-toolkit@latest
```

--------------------------------

### Network Setup Script

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/exec

This shell script installs network tools, tests connectivity to google.com, and sets network status and IP address in EXEC_OUTPUT.

```sh
#!/bin/sh
1
# Install network tools
2
apk add --no-cache curl netcat-openbsd
3

4
# Test network connectivity
5
ping -c 3 google.com
6

7
# Set network status
8
echo "NETWORK_READY=true" >> $EXEC_OUTPUT
9
echo "IP_ADDRESS=$(hostname -i)" >> $EXEC_OUTPUT
10
```

--------------------------------

### Working Directory and File Setup

Source: https://docs.labs.instruqt.com/reference/functions/lab-environment

Demonstrates setting up a workspace, configuration directory, and script directory using lab environment functions. It also shows copying lab files and creating a setup script.

```hcl
# Create organized workspace structure
locals {
  workspace_dir = data("workspace")
  config_dir = data("configs")
  scripts_dir = data_with_permissions("scripts", 755)
}


resource "copy" "lab_files" {
  source = "./files/"
  destination = local.workspace_dir
}


resource "template" "setup_script" {
  source = <<-EOF
    #!/bin/bash
    export WORKSPACE="${local.workspace_dir}"
    export CONFIG_DIR="${local.config_dir}"
    cd $WORKSPACE
  EOF


  destination = "${local.scripts_dir}/setup.sh"
}
```

--------------------------------

### Basic Terminal Example

Source: https://docs.labs.instruqt.com/reference/sandbox/ui/terminal

A straightforward example of creating a terminal resource that connects to a specified container.

```hcl
resource "terminal" "main" {
  target = resource.container.ubuntu
}
```

--------------------------------

### Full Nomad Cluster Configuration Example

Source: https://docs.labs.instruqt.com/reference/sandbox/orchestration/nomad/nomadcluster

A comprehensive example demonstrating various configuration options for a Nomad cluster. This includes network settings, node counts, environment variables, custom configuration file paths, Docker image details, volume mounts, port mappings, and driver configurations. Use this as a template for complex setups.

```hcl
resource "nomad_cluster" "name" {
  # Network configuration
  network {
    id = resource.network.main
    ip_address = "10.0.0.10"
    aliases = ["nomad", "server"]
  }

  # Optional cluster configuration
  client_nodes = 3
  datacenter = "dc1"
  environment = {
    NOMAD_LOG_LEVEL = "INFO"
    CUSTOM_VAR = "value"
  }

  # Configuration files
  server_config = "./nomad/server.hcl"
  client_config = "./nomad/client.hcl"
  consul_config = "./consul/config.hcl"

  # Image configuration
  image {
    name = "hashicorp/nomad:1.8.4"
    username = "username"
    password = "password"
  }

  # Volume mounts
  volume {
    source = "./nomad-data"
    destination = "/opt/nomad/data"
    type = "bind"
    read_only = false
  }

  # Port mappings
  port {
    local = 4646
    host = 4646
    protocol = "tcp"
  }

  port_range {
    local_range = "8000-8010"
    host_range = "8000-8010"
    protocol = "tcp"
  }

  # Image copying
  copy_image {
    name = "myapp:latest"
    username = "registry_user"
    password = "registry_pass"
  }

  # Driver configuration
  config {
    docker {
      no_proxy = ["registry.local"]
      insecure_registries = ["registry.local:5000"]
    }
  }

  open_in_browser = false
}
```

--------------------------------

### Local File Editing Example

Source: https://docs.labs.instruqt.com/reference/sandbox/ui/editor

Configures an editor resource to access local directories for configuration templates and setup scripts.

```hcl
resource "editor" "config_editor" {
  workspace "templates" {
    directory = "assets/config-templates"
  }

  workspace "scripts" {
    directory = "files/setup-scripts"
  }
}
```

--------------------------------

### Start Application with Exec Resource

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/exec

This snippet demonstrates how to use the `exec` resource to start an application as a daemon. It depends on the `configure_app` resource and specifies the script to run.

```hcl
resource "exec" "start_app" {
  depends_on = [resource.exec.configure_app]

  script = "scripts/exec/start_app/script.sh"
  daemon = true
}
```

--------------------------------

### Question with Hints Example

Source: https://docs.labs.instruqt.com/reference/content/quiz/singlechoicequestion

An example demonstrating how to include hints for a single choice question, along with tags for organization.

```hcl
resource "single_choice_question" "networking_advanced" {
  question = "Which HTTP status code indicates a successful request?"
  answer   = "200"

  distractors = [
    "404",
    "500",
    "302"
  ]

  hints = [
    "This is a 2xx status code",
    "It's the most common success status code"
  ]

  tags = ["http", "networking", "status-codes"]
}
```

--------------------------------

### Simple Job Deployment Example

Source: https://docs.labs.instruqt.com/reference/sandbox/orchestration/nomad/nomadjob

A basic example demonstrating the deployment of a single job file ('nginx.nomad') to a 'dev' cluster. Requires a 'nomad_cluster' resource definition.

```hcl
resource "nomad_cluster" "dev" {
  network {
    id = resource.network.main
  }
}

resource "nomad_job" "web" {
  cluster = resource.nomad_cluster.dev
  paths = ["./jobs/nginx.nomad"]
}
```

--------------------------------

### Simple Private Registry Example

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/cache/registry

An example of configuring the Docker Hub registry with authentication credentials.

```APIDOC
## resource "container_registry" "dockerhub"

### Description
Configures the Docker Hub registry with authentication.

### Fields
- **hostname** (string) - Required - Hostname of the registry
- **auth** (block) - Optional - Authentication configuration for the registry
  - **username** (string) - Required - Username for authentication
  - **password** (string) - Required - Password for authentication

### Example
```hcl
resource "container_registry" "dockerhub" {
  hostname = "registry.hub.docker.com"

  auth {
    username = "mydockerhubuser"
    password = var.dockerhub_password
  }
}
```
```

--------------------------------

### Build Script Content

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/exec

Example script for building an application within a container. It installs dependencies, runs a build command, and sets output variables.

```bash
#!/bin/sh
cd /app
npm install
npm run build

echo "BUILD_STATUS=success" >> $EXEC_OUTPUT
echo "BUILD_TIME=$(date -Iseconds)" >> $EXEC_OUTPUT
```

--------------------------------

### Verify Instruqt CLI Installation

Source: https://docs.labs.instruqt.com/getting-started/code/overview

Execute this command to confirm the Instruqt CLI is installed and check its version. Ensure you have authenticated the CLI.

```bash
instruqt version
```

```text
Version: 2265-8b823dd
```

--------------------------------

### Configuration File Management Example

Source: https://docs.labs.instruqt.com/reference/functions/filesystem

Demonstrates reading and parsing a JSON configuration file, and checking environment variables for conditional logic.

```HCL
# Read and parse configuration
locals {
  config_content = file("./config.json")
  config = jsondecode(local.config_content)
}

# Check if we're in development
locals {
  is_dev = env("NODE_ENV") == "development"
}
```

--------------------------------

### Environment-based Configuration Example

Source: https://docs.labs.instruqt.com/reference/functions/filesystem

Shows how to use environment variables for configuration, providing defaults and dynamically building a configuration map.

```HCL
locals {
  # Use environment variables with defaults
  log_level = env("LOG_LEVEL") != "" ? env("LOG_LEVEL") : "info"
  debug_enabled = env("DEBUG") == "true"

  # Build configuration based on environment
  config = {
    log_level = local.log_level
    debug = local.debug_enabled
    home_dir = home()
  }
}

resource "template" "env_config" {
  source = template_file("./config.tpl", local.config)
  destination = "./runtime-config.json"
}
```

--------------------------------

### Local Script Content

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/exec

Example script for local execution. It updates package lists, installs dependencies, and sets output variables.

```bash
#!/bin/bash
echo "Setting up environment..."

# Install dependencies
sudo apt-get update
sudo apt-get install -y curl wget

# Set output variables
echo "SETUP_COMPLETE=true" >> $EXEC_OUTPUT
echo "VERSION=1.0.0" >> $EXEC_OUTPUT
```

--------------------------------

### Simple GET Request Example

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/http

A practical example of a simple GET request to check the status of an endpoint. It also shows how to access the computed status code.

```hcl
resource "http" "api_check" {
  method = "GET"
  url = "https://httpbin.org/status/200"
}

output "api_status" {
  value = resource.http.api_check.status
}
```

--------------------------------

### Basic Terraform Configuration Example

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/terraform

An example demonstrating a basic Terraform resource configuration with a specified source directory and variables.

```APIDOC
## terraform.aws_vpc

### Description
Provisions AWS VPC infrastructure using a local Terraform configuration.

### Fields
- **source** (string) - Required - Path to the Terraform configuration directory.
- **variables** (map(string)) - Optional - Variables to pass to the Terraform configuration.
  - **region** (string) - The AWS region for the VPC.
  - **environment** (string) - The environment type (e.g., 'lab').
```

--------------------------------

### Example values.yaml for Production

Source: https://docs.labs.instruqt.com/reference/sandbox/orchestration/helm/helm

A comprehensive example of a `values.yaml` file for a production deployment. It includes configurations for replica count, image details, service type, resource limits, autoscaling, and ingress settings.

```yaml
replicaCount: 3

image:
  repository: myapp/webapp
  tag: "1.2.0"
  pullPolicy: Always

service:
  type: LoadBalancer
  port: 80
  targetPort: 8080

resources:
  limits:
    cpu: 500m
    memory: 512Mi
  requests:
    cpu: 250m
    memory: 256Mi

autoscaling:
  enabled: true
  minReplicas: 3
  maxReplicas: 10
  targetCPUUtilizationPercentage: 70

ingress:
  enabled: true
  className: "nginx"
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
  hosts:
    - host: webapp.example.com
      paths:
        - path: /
          pathType: Prefix
  tls:
    - secretName: webapp-tls
      hosts:
        - webapp.example.com
```

--------------------------------

### Multi-file Configuration Example

Source: https://docs.labs.instruqt.com/reference/functions/filesystem

Demonstrates reading and merging configuration from multiple JSON files, including a base configuration and an environment-specific override.

```HCL
locals {
  # Read multiple configuration files
  base_config = jsondecode(file("./config/base.json"))
  env_config = jsondecode(file("./config/${env("ENVIRONMENT")}.json"))

  # Merge configurations
  final_config = merge(local.base_config, local.env_config)
}
```

--------------------------------

### Initialize Git Repository

Source: https://docs.labs.instruqt.com/getting-started/code/project-setup

Use this command to start tracking changes in your project directory with Git.

```bash
git init
```

--------------------------------

### Basic Ingress Syntax

Source: https://docs.labs.instruqt.com/reference/sandbox/networking/ingress

This example demonstrates the basic syntax for creating an ingress resource to expose a Kubernetes service to the local machine.

```APIDOC
## Basic Ingress Syntax

```hcl
resource "ingress" "name" {
  port = 8080

  target {
    resource = resource.kubernetes_cluster.k8s
    port     = 80

    config = {
      service   = "my-service"
      namespace = "default"
    }
  }
}
```
```

--------------------------------

### Expose Kubernetes Dashboard Example

Source: https://docs.labs.instruqt.com/reference/sandbox/networking/ingress

This example shows how to expose the Kubernetes dashboard service running in a cluster to the local machine.

```APIDOC
## Expose Kubernetes Dashboard

```hcl
resource "ingress" "k8s_dashboard" {
  port = 8080

  target {
    resource = resource.kubernetes_cluster.training
    port     = 443

    config = {
      service   = "kubernetes-dashboard"
      namespace = "kubernetes-dashboard"
    }
  }
}
```
```

--------------------------------

### Basic HTTP Service Example

Source: https://docs.labs.instruqt.com/reference/sandbox/ui/service

Example of a service resource exposing a web application on a specific port.

```hcl
resource "service" "webapp" {
  target = resource.container.app
  port   = 3000
}
```

--------------------------------

### HTTPS Service with Path Example

Source: https://docs.labs.instruqt.com/reference/sandbox/ui/service

Example of a service resource configured for HTTPS with a custom path.

```hcl
resource "service" "dashboard" {
  target = resource.container.monitoring
  scheme = "https"
  port   = 3000
  path   = "/dashboard"
}
```

--------------------------------

### Start Application Script

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/exec

This bash script starts the application in the background using nohup, captures its PID, and records the PID and startup status in EXEC_OUTPUT.

```bash
#!/bin/bash
1
APP_PATH="${resource.exec.download_app.output.DOWNLOAD_PATH}"
2
cd "$APP_PATH"
3

4
nohup ./bin/app > app.log 2>&1 &
5
APP_PID=$!
6

7

echo "APP_PID=$APP_PID" >> $EXEC_OUTPUT
8
echo "APP_STARTED=true" >> $EXEC_OUTPUT
9
```

--------------------------------

### Verify Git Installation

Source: https://docs.labs.instruqt.com/getting-started/code/overview

Run this command to check if Git is installed and its version. Ensure Git is configured with your name and email.

```bash
git --version
```

```text
git version 2.49.0
```

--------------------------------

### Full Ingress Syntax

Source: https://docs.labs.instruqt.com/reference/sandbox/networking/ingress

This example shows the full syntax for an ingress resource, including the `expose_local` field and using a named port.

```APIDOC
## Full Ingress Syntax

```hcl
resource "ingress" "name" {
  port          = 8080
  expose_local  = false

  target {
    resource  = resource.kubernetes_cluster.k8s
    port      = 80
    named_port = "http"

    config = {
      service   = "kubernetes-dashboard"
      namespace = "kubernetes-dashboard"
    }
  }
}
```
```

--------------------------------

### API Authentication Example

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/http

Demonstrates how to authenticate with an API using a POST request and then access a protected resource using the obtained token.

```APIDOC
## API Authentication

### Description
This example illustrates a two-step process: first, authenticating with an API to get a token, and second, using that token in the 'Authorization' header to access a protected resource.

### Method
POST (for authentication), GET (for protected resource)

### Endpoint
POST: https://api.example.com/auth/login
GET: https://api.example.com/protected/data

### Fields
- `method` (string) - Required - HTTP method (GET, POST, PUT, DELETE, etc.)
- `url` (string) - Required - Target URL for the HTTP request
- `headers` (map(string)) - Optional - HTTP headers to send with the request.
- `payload` (string) - Optional - Request body/payload

### Request Example
```hcl
resource "random_password" "api_token" {
  length = 32
  special = false
}

resource "http" "authenticate" {
  method = "POST"
  url = "https://api.example.com/auth/login"

  headers = {
    "Content-Type" = "application/json"
  }

  payload = jsonencode({
    username = "admin"
    password = "secret"
  })
}

resource "http" "protected_resource" {
  depends_on = [resource.http.authenticate]

  method = "GET"
  url = "https://api.example.com/protected/data"

  headers = {
    "Authorization" = "Bearer ${jsondecode(resource.http.authenticate.body).token}"
    "Accept" = "application/json"
  }
}
```

### Response
#### Success Response (200)
- `body` (string) - Response body content (contains token for authentication, and data for protected resource)

### Response Example
(Response body will vary based on API responses for authentication and protected resource access.)
```

--------------------------------

### Template Processing Example

Source: https://docs.labs.instruqt.com/reference/functions/filesystem

Generates an application configuration file from a template, passing environment-specific variables and environment settings.

```HCL
# Generate configuration from template
resource "template" "app_config" {
  source = template_file("./templates/app.conf.tpl", {
    environment = var.environment
    database_url = var.db_connection_string
    api_keys = var.api_keys
    debug_mode = env("DEBUG") == "true"
  })

  destination = "./app.conf"
}
```

--------------------------------

### Container Network Setup with Exec Resource

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/exec

This snippet sets up a container network using the `exec` resource. It specifies an Alpine Linux image, network configuration with a static IP and alias, and a script for network setup.

```hcl
resource "network" "app" {
  subnet = "10.0.1.0/24"
}

resource "exec" "network_setup" {
  image {
    name = "alpine:latest"
  }

  network {
    id = resource.network.app
    ip_address = "10.0.1.10"
    aliases = ["setup-container"]
  }

  script = "scripts/exec/network_setup/script.sh"
}
```

--------------------------------

### Handlebars Template Example

Source: https://docs.labs.instruqt.com/reference/content/note

Demonstrates Handlebars template syntax for dynamic content within a note, including variable substitution.

```markdown
1
## API Reference for {{service_name}}
2

3
Base URL: {{api_url}}
4
Version: {{version}}
5
Default Port: {{port}}
6

7
## Connection Example
8

9
```bash
10
curl {{api_url}}/v{{version}}/status

11
```


```

--------------------------------

### Dynamic Resource Creation with for_each

Source: https://docs.labs.instruqt.com/reference/functions/collection

Example of using a variable to dynamically create multiple resources based on a list of environments.

```hcl
variable "environments" {
  default = ["dev", "staging", "prod"]
}

resource "container" "app" {
  for_each = toset(var.environments)

  image {
    name = "app:${each.value}"
  }
}
```

--------------------------------

### Certificate Hierarchy Example

Source: https://docs.labs.instruqt.com/reference/sandbox/certificates/cert

Illustrates a typical certificate hierarchy, starting from a Certificate Authority (CA) down to leaf certificates for various services.

```plaintext
1
Certificate Authority (CA)
2
├── Intermediate CA (optional)
3
└── Leaf Certificates
4
    ├── Web Server Certificates
5
    ├── Client Certificates
6
    └── Service-to-Service Certificates
```

--------------------------------

### Create Instructions Directory

Source: https://docs.labs.instruqt.com/getting-started/code/content-tasks

Creates the directory for learner instructions.

```bash
mkdir -p instructions
```

--------------------------------

### Database Setup Configuration

Source: https://docs.labs.instruqt.com/reference/sandbox/orchestration/k8s/config

Applies a set of Kubernetes manifests for setting up a PostgreSQL database, including secrets, PVC, deployment, and service.

```hcl
resource "kubernetes_config" "database" {
  cluster = resource.kubernetes_cluster.data
  paths = [
    "./k8s/postgres-secret.yaml",
    "./k8s/postgres-pvc.yaml",
    "./k8s/postgres-deployment.yaml",
    "./k8s/postgres-service.yaml"
  ]
  wait_until_ready = true

  health_check {
    timeout = "120s"
    pods = ["app=postgresql"]
  }
}
```

--------------------------------

### Path Construction Example

Source: https://docs.labs.instruqt.com/reference/functions/filesystem

Illustrates building file paths relative to the current file's directory and using the user's home directory.

```HCL
locals {
  # Build paths relative to current file
  current_dir = dir()
  config_file = "${local.current_dir}/config.json"

  # Use home directory
  user_config = "${home()}/.config/app/settings.json"
}
```

--------------------------------

### Container Security Practices Multiple Choice Question

Source: https://docs.labs.instruqt.com/reference/content/quiz/multiplechoicequestion

An example of a multiple choice question focused on recommended security practices for containers. Includes multiple correct answers and hints to guide users.

```hcl
resource "multiple_choice_question" "security_practices" {
  question = "Which of the following are recommended security practices for containers?"

  answer = [
    "Use minimal base images",
    "Scan images for vulnerabilities",
    "Run containers as non-root users",
    "Keep container images updated"
  ]

  distractors = [
    "Store secrets in image files",
    "Use the latest tag for production"
  ]

  hints = [
    "Think about reducing attack surface",
    "Consider secrets management and image versioning"
  ]

  tags = ["security", "containers", "best-practices"]
}
```

--------------------------------

### Webhook Testing Example

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/http

Sets up an HTTP POST request to test a webhook, including custom headers and a JSON payload with dynamic data.

```APIDOC
## Webhook Testing

### Description
This example demonstrates how to send a POST request to a webhook URL, simulating an event with custom headers and a JSON payload containing dynamic information like timestamps.

### Method
POST

### Endpoint
https://webhook.site/unique-id

### Fields
- `method` (string) - Required - HTTP method (GET, POST, PUT, DELETE, etc.)
- `url` (string) - Required - Target URL for the HTTP request
- `headers` (map(string)) - Optional - HTTP headers to send with the request.
- `payload` (string) - Optional - Request body/payload
- `timeout` (string) - Optional - Request timeout duration. Defaults to ”30s”.

### Request Example
```hcl
resource "http" "webhook_test" {
  method = "POST"
  url = "https://webhook.site/unique-id"

  headers = {
    "Content-Type" = "application/json"
    "X-Event-Type" = "test"
  }

  payload = jsonencode({
    event = "lab_started"
    lab_id = "introduction-to-apis"
    user_id = "student123"
    timestamp = timestamp()
  })

  timeout = "10s"
}
```
```

--------------------------------

### Run Nginx Container with Port Mapping

Source: https://docs.labs.instruqt.com/reference/content/note

Use `docker run` to create and start a new container. This example maps host port 8080 to container port 80 and runs the Nginx image.

```bash
docker run -p 8080:80 nginx
```

--------------------------------

### Initialize New Lab Project

Source: https://docs.labs.instruqt.com/development/creating-labs

Use this command to create a new lab project directory and then navigate into it.

```bash
instruqt lab create my-new-lab
cd my-new-lab
```

--------------------------------

### Deploy Helm Chart with High Availability Setup

Source: https://docs.labs.instruqt.com/reference/sandbox/orchestration/helm/helm

Configure a Helm chart for high availability, specifying a chart version, repository, and detailed values for HA configuration. This example deploys Vault with HA enabled.

```hcl
resource "helm" "vault" {
  cluster = resource.k8s_cluster.production
  chart = "vault"
  version = "0.25.0"
  namespace = "vault-system"
  create_namespace = true

  repository {
    name = "hashicorp"
    url = "https://helm.releases.hashicorp.com"
  }

  values = "./config/vault-ha.yaml"

  values_string = {
    "server.ha.enabled" = "true"
    "server.ha.replicas" = "3"
    "server.ha.raft.enabled" = "true"
    "ui.enabled" = "true"
    "ui.serviceType" = "LoadBalancer"
    "server.resources.requests.memory" = "256Mi"
    "server.resources.requests.cpu" = "250m"
  }

  retry = 3
  timeout = "600s"

  health_check {
    timeout = "300s"
    pods = [
      "app.kubernetes.io/name=vault",
      "component=server"
    ]
  }
}
```

--------------------------------

### Example Module: Web Server Main Configuration

Source: https://docs.labs.instruqt.com/reference/types/module

Implements the core logic for a web server module, defining a container resource and a template resource for configuration files. Uses input variables to customize the deployment.

```hcl
resource "container" "web" {
  image {
    name = "nginx:${variable.image_tag}"
  }

  container_name = variable.server_name

  port {
    local  = variable.port
    remote = 80
  }
}

resource "template" "config" {
  source      = "templates/nginx.conf.tpl"
  destination = "./nginx.conf"

  vars = {
    server_name = variable.server_name
    listen_port = variable.port
  }
}
```

--------------------------------

### Initialize New Lab with Skeleton Template

Source: https://docs.labs.instruqt.com/getting-started/code/project-setup

Use the Instruqt CLI to create a new lab project. Select the 'skeleton' template for a minimal starting structure. This command prompts for lab title, template choice, and target directory.

```bash
instruqt lab init

? Lab title: My Web Server Lab
? Select a template: skeleton
? Target directory (./my-web-server-lab):
[OK] Lab created successfully at ./my-web-server-lab
```

--------------------------------

### Start Instruqt Lab Locally for Testing

Source: https://docs.labs.instruqt.com/development/testing

This command allows you to test your lab environment directly on your local machine without deploying it. It's crucial for iterative development and debugging.

```bash
instruqt lab start --local
```

--------------------------------

### Setup Application Environment

Source: https://docs.labs.instruqt.com/reference/sandbox/storage/copy

Copies application source code, configuration files, and node modules. The configuration file copy depends on the source code copy.

```hcl
# Copy application source code
resource "copy" "source_code" {
  source = "github.com/mycompany/webapp//src"
  destination = "./app/src/"
  permissions = "0644"
}

# Copy configuration files
resource "copy" "config_files" {
  depends_on = [resource.copy.source_code]

  source = "./config/app.yaml"
  destination = "./app/config/app.yaml"
  permissions = "0600"
}

# Download dependencies
resource "copy" "node_modules" {
  source = "https://registry.npmjs.org/@mycompany/shared/-/shared-1.0.0.tgz"
  destination = "./app/node_modules/"
  permissions = "0644"
}
```

--------------------------------

### Registry with Different Auth Endpoint Example

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/cache/registry

An example of configuring a corporate registry with a distinct authentication endpoint.

```APIDOC
## resource "container_registry" "corporate"

### Description
Configures a corporate registry with a separate authentication endpoint.

### Fields
- **hostname** (string) - Required - Hostname of the registry
- **auth** (block) - Optional - Authentication configuration for the registry
  - **hostname** (string) - Optional - Hostname for authentication (can differ from registry hostname)
  - **username** (string) - Required - Username for authentication
  - **password** (string) - Required - Password for authentication

### Example
```hcl
resource "container_registry" "corporate" {
  hostname = "registry.corp.example.com"

  auth {
    hostname = "auth.corp.example.com"
    username = "service-bot"
    password = var.corporate_registry_token
  }
}
```
```

--------------------------------

### File Permission Examples

Source: https://docs.labs.instruqt.com/reference/sandbox/storage/copy

Demonstrates setting different file permissions for various file types, including read-only configuration, executable scripts, sensitive files, and public assets.

```hcl
# Read-only configuration files
resource "copy" "readonly_config" {
  source = "./config.yaml"
  destination = "./app/config.yaml"
  permissions = "0444"  # Read-only for all users
}

# Executable scripts
resource "copy" "startup_script" {
  source = "./startup.sh"
  destination = "./app/startup.sh"
  permissions = "0755"  # Read/execute for all, write for owner
}

# Sensitive files (owner only)
resource "copy" "secrets" {
  source = "./secrets.env"
  destination = "./app/secrets.env"
  permissions = "0600"  # Read/write for owner only
}

# Public files
resource "copy" "public_assets" {
  source = "./public/"
  destination = "./app/public/"
  permissions = "0644"  # Read for all, write for owner
}
```

--------------------------------

### Markdown List Examples

Source: https://docs.labs.instruqt.com/ui-overview/adding-content/markdown-editor

Create unordered (bulleted) or ordered (numbered) lists using markdown syntax. The example shows both types.

```markdown
1
- Bullet list item
2
- Another item
3


4
1. Numbered list
5
2. Second item
```

--------------------------------

### Basic Geography Question Example

Source: https://docs.labs.instruqt.com/reference/content/quiz/singlechoicequestion

An example of a single choice question focused on basic geography, specifying the question, answer, and distractors.

```hcl
resource "single_choice_question" "geography_basic" {
  question = "What is the capital of Japan?"
  answer   = "Tokyo"

  distractors = [
    "Osaka",
    "Kyoto",
    "Hiroshima"
  ]
}
```

--------------------------------

### Execute Platform-Specific Commands

Source: https://docs.labs.instruqt.com/reference/functions/lab-environment

Installs a tool using the appropriate package manager for the current operating system (e.g., 'brew' for macOS, 'apt-get' for Linux). Ensure the package manager is available.

```HCL
# Use platform-specific commands
resource "exec" "install" {
  command = system("os") == "darwin" ? "brew" : "apt-get"
  arguments = system("os") == "darwin" ?
    ["install", "tool"] :
    ["install", "-y", "tool"]
}
```

--------------------------------

### Note Resource for Troubleshooting Guide

Source: https://docs.labs.instruqt.com/reference/content/note

Configures a note resource for a troubleshooting guide, including variables for support email and documentation URL.

```hcl
1
resource "note" "troubleshooting" {
2
  file = "notes/common-issues.md"
3

4
  variables = {
5
    support_email = "support@example.com"
6
    docs_url      = "https://docs.example.com"
7
  }
8
}


```

--------------------------------

### Technical Knowledge Question Example

Source: https://docs.labs.instruqt.com/reference/content/quiz/singlechoicequestion

An example of a single choice question testing technical knowledge about Docker commands, including relevant tags.

```hcl
resource "single_choice_question" "docker_concepts" {
  question = "Which Docker command is used to create and start a new container?"
  answer   = "docker run"

  distractors = [
    "docker start",
    "docker create",
    "docker exec"
  ]

  tags = ["docker", "containers", "commands"]
}
```

--------------------------------

### Complex Page Resource Example

Source: https://docs.labs.instruqt.com/reference/content/page

An advanced example demonstrating a page resource with both variables and activities. This allows for highly dynamic and interactive learning experiences.

```hcl
1
resource "page" "advanced_tutorial" {
2
  title = "Advanced Container Management"
3
  file  = "instructions/advanced/tutorial.md"
4

5
  variables = {
6
    registry_url = "registry.example.com"
7
    namespace    = "production"
8
    image_tag    = "v1.0.0"
9
  }
10

11
  activities = {
12
    build_image     = resource.task.build_custom_image
13
    deploy_app      = resource.task.deploy_application
14
    scaling_quiz    = resource.quiz.scaling_concepts
15
    cleanup_task    = resource.task.cleanup_resources
16
  }
17
}

```

--------------------------------

### Multi-Tier Architecture Example

Source: https://docs.labs.instruqt.com/reference/types/resource

Demonstrates a common multi-tier architecture pattern with separate resources for database, API, and web presentation layers. Dependencies ensure correct deployment order.

```hcl
# Database tier
resource "container" "database" {
  image {
    name = "postgres:13"
  }
  container_name = "db-server"
}

# Application tier
resource "container" "api" {
  depends_on = ["resource.container.database"]

  image {
    name = "api:latest"
  }

  environment = {
    DB_HOST = resource.container.database.meta.name
  }
}

# Presentation tier
resource "container" "web" {
  depends_on = ["resource.container.api"]

  image {
    name = "web:latest"
  }

  environment = {
    API_URL = format("http://%s:8080", resource.container.api.meta.name)
  }
}
```

--------------------------------

### Local Module Example with Resource Reference

Source: https://docs.labs.instruqt.com/reference/types/module

Import a local module and reference its resources. This demonstrates how to use local modules for reusable infrastructure components and integrate them into other resources.

```hcl
module "database" {
  source = "./modules/postgres"

  variables = {
    database_name = "myapp"
    username      = "admin"
    port         = 5432
  }
}

# Reference module resources
resource "container" "app" {
  image {
    name = "myapp:latest"
  }

  environment = {
    DB_HOST = module.database.resource.container.postgres.meta.name
    DB_PORT = "5432"
  }
}
```

--------------------------------

### Simple Definition Question Example

Source: https://docs.labs.instruqt.com/reference/content/quiz/textanswerquestion

A practical example of a text answer question for defining a concept, like a Kubernetes Pod. Tags are used for categorization.

```hcl
resource "text_answer_question" "define_pod" {
  question = "What is a Pod in Kubernetes?"
  answer   = "smallest deployable unit"

  tags = ["kubernetes", "concepts", "pods"]
}

```

--------------------------------

### API Authentication Example

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/http

Shows how to authenticate with an API by first performing a login request to obtain a token, then using that token in subsequent requests to access protected resources.

```hcl
resource "random_password" "api_token" {
  length = 32
  special = false
}

resource "http" "authenticate" {
  method = "POST"
  url = "https://api.example.com/auth/login"

  headers = {
    "Content-Type" = "application/json"
  }

  payload = jsonencode({
    username = "admin"
    password = "secret"
  })
}

resource "http" "protected_resource" {
  depends_on = [resource.http.authenticate]

  method = "GET"
  url = "https://api.example.com/protected/data"

  headers = {
    "Authorization" = "Bearer ${jsondecode(resource.http.authenticate.body).token}"
    "Accept" = "application/json"
  }
}
```

--------------------------------

### Basic HTTP GET Request

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/http

Defines a basic HTTP GET request to a specified URL. Useful for checking service status or fetching simple data.

```hcl
resource "http" "name" {
  method = "GET"
  url = "https://api.example.com/status"
}
```

--------------------------------

### Deploy Simple Chart from Repository

Source: https://docs.labs.instruqt.com/reference/sandbox/orchestration/helm/helm

Deploys the 'nginx' chart from the Bitnami repository with specified service type and replica count. This example demonstrates overriding default values using `values_string`.

```hcl
resource "k8s_cluster" "dev" {
  network {
    id = resource.network.main
  }
}

resource "helm" "nginx" {
  cluster = resource.k8s_cluster.dev
  chart = "nginx"

  repository {
    name = "bitnami"
    url = "https://charts.bitnami.com/bitnami"
  }


  values_string = {
    "service.type" = "ClusterIP"
    "replicaCount" = "2"
  }
}
```

--------------------------------

### Command Usage Question Example

Source: https://docs.labs.instruqt.com/reference/content/quiz/textanswerquestion

An example of a text answer question designed to test knowledge of a specific command. The 'exact = true' setting ensures the answer must match precisely.

```hcl
resource "text_answer_question" "docker_command" {
  question = "What Docker command lists all running containers?"
  answer   = "docker ps"

  exact = true

  tags = ["docker", "commands"]
}

```

--------------------------------

### Simple Server Certificate Generation

Source: https://docs.labs.instruqt.com/reference/sandbox/certificates/cert/certificateleaf

Example demonstrating the generation of a simple server certificate using the certificate_leaf resource. It includes the creation of a root CA and then uses its key and certificate to sign the leaf certificate.

```hcl
resource "certificate_ca" "root" {
  output = "./ca"
}

resource "certificate_leaf" "server" {
  ca_key  = resource.certificate_ca.root.private_key.path    # e.g., "./ca/private_key.pem"
  ca_cert = resource.certificate_ca.root.certificate.path    # e.g., "./ca/certificate.pem"
  output  = "./server-certs"

  dns_names    = ["localhost"]
  ip_addresses = ["127.0.0.1"]
}

output "server_cert_path" {
  value = resource.certificate_leaf.server.certificate.path  # e.g., "./server-certs/certificate.pem"
}
```

--------------------------------

### Nomad Job File Example (nginx)

Source: https://docs.labs.instruqt.com/reference/sandbox/orchestration/nomad/nomadjob

An example Nomad job specification file for deploying an Nginx service. It includes service definition, network ports, health checks, and resource allocation.

```nomad
## ./jobs/web.nomad
job "web" {
  datacenters = ["dc1"]
  type = "service"

  group "web" {
    count = 3

    network {
      port "http" {
        to = 80
      }
    }

    task "nginx" {
      driver = "docker"

      config {
        image = "nginx:latest"
        ports = ["http"]
      }

      service {
        name = "web"
        port = "http"

        check {
          type = "http"
          path = "/"
          interval = "10s"
          timeout = "2s"
        }
      }

      resources {
        cpu    = 100
        memory = 128
      }
    }
  }
}
```

--------------------------------

### Example Module: Web Server Variables

Source: https://docs.labs.instruqt.com/reference/types/module

Defines input variables for a web server module, including server name, port, and Docker image tag. Provides default values and descriptions for clarity.

```hcl
variable "server_name" {
  default     = "web-server"
  description = "Name of the web server"
}

variable "port" {
  default     = 80
  description = "Port for the web server"
}

variable "image_tag" {
  default     = "latest"
  description = "Docker image tag to use"
}
```

--------------------------------

### Web Server Configuration Example

Source: https://docs.labs.instruqt.com/reference/sandbox/storage/template

Generates an Nginx web server configuration using an inline template with variables for port, server name, document root, and API backend details.

```hcl
resource "template" "nginx_site" {
  source = <<-EOF
    server {
      listen {{port}};
      server_name {{server_name}};
      root {{document_root}};

      location / {
        try_files $uri $uri/ =404;
      }

      location /reference/ {
        proxy_pass http://{{api_host}}:{{api_port}};
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
      }
    }
  EOF

  destination = "./nginx/sites-available/webapp"

  variables = {
    port          = "80"
    server_name   = "webapp.local"
    document_root = "/var/www/webapp"
    api_host      = "localhost"
    api_port      = "3000"
  }
}
```

--------------------------------

### Network Communication Examples

Source: https://docs.labs.instruqt.com/reference/sandbox/networking/network

Illustrates different methods for a web container to communicate with a database container on the same network, using container names, aliases, and IP addresses.

```bash
## From web container to db container
curl http://db:5432
curl http://database:5432
curl http://10.0.100.20:5432
```

--------------------------------

### env(name)

Source: https://docs.labs.instruqt.com/reference/functions/filesystem

Gets the value of an environment variable.

```APIDOC
## env(name)

### Description
Gets the value of an environment variable.

### Parameters
* `name` (string) - Environment variable name

### Returns
Environment variable value or empty string

### Example
```
env("HOME")                       # Returns: "/home/user"
env("PATH")                       # Returns: system PATH
env("CUSTOM_VAR")                 # Returns: value or ""
```
```

--------------------------------

### slice

Source: https://docs.labs.instruqt.com/reference/functions/collection

Extracts a portion of a list using start and end indices.

```APIDOC
## slice

### Description
Extracts a portion of a list.

### Signature
```
slice(list, start, end)
```

### Parameters
* `list` - List to slice
* `start` - Starting index (inclusive)
* `end` - Ending index (exclusive)

### Returns
Extracted portion

### Example
```
slice(["a", "b", "c", "d"], 1, 3)      # Returns: ["b", "c"]
slice([1, 2, 3, 4, 5], 0, 2)           # Returns: [1, 2]
slice(["a", "b", "c"], 2, 10)          # Returns: ["c"]
```
```

--------------------------------

### Resource Chain Example: Multi-Resource Deployment

Source: https://docs.labs.instruqt.com/reference/types/resource

Illustrates a sequence of resource creations, including a network, a database container, an application container, a service, and a terminal. Dependencies are explicitly managed.

```hcl
# 1. Create network
resource "network" "lab_network" {
  subnet = "10.0.0.0/16"
}

# 2. Create database container
resource "container" "database" {
  depends_on = ["resource.network.lab_network"]

  image {
    name = "postgres:13"
  }

  network {
    id = resource.network.lab_network.meta.id
  }

  environment = {
    POSTGRES_DB = "appdb"
  }
}

# 3. Create application container
resource "container" "app" {
  depends_on = ["resource.container.database"]

  image {
    name = "myapp:latest"
  }

  network {
    id = resource.network.lab_network.meta.id
  }

  environment = {
    DATABASE_HOST = resource.container.database.meta.name
  }
}

# 4. Create user interface
resource "service" "app_ui" {
  target = resource.container.app
  port   = 8080
  title  = "My Application"
}

# 5. Create terminal for access
resource "terminal" "app_terminal" {
  target = resource.container.app
  shell  = "/bin/bash"
}
```

--------------------------------

### substr

Source: https://docs.labs.instruqt.com/reference/functions/string

Extracts a substring from a given string based on a starting position and length.

```APIDOC
## substr(string, offset, length)

### Description
Extracts a substring by position and length.

### Parameters
#### Path Parameters
- **string** (string) - Required - String to extract from
- **offset** (number) - Required - Starting position (0-based)
- **length** (number) - Required - Maximum characters to extract

### Returns
Extracted substring

### Example
```
substr("hello world", 0, 5)     // Returns: "hello"
substr("hello world", 6, 5)     // Returns: "world"
substr("hello world", 6, 100)   // Returns: "world" (length exceeds string)
```
```

--------------------------------

### String Variable Example

Source: https://docs.labs.instruqt.com/reference/types/variable

Defines a string variable for a username and uses it in a container environment variable.

```hcl
variable "username" {
  default     = "admin"
  description = "Default username for system access"
}


resource "container" "web" {
  image {
    name = "nginx:latest"
  }

  environment = {
    USER = variable.username
  }
}
```

--------------------------------

### Database Initialization Script

Source: https://docs.labs.instruqt.com/reference/sandbox/utilities/exec

Script to initialize a PostgreSQL database. It waits for the database to be ready and then creates a 'users' table.

```bash
#!/bin/bash
# Wait for database to be ready
until pg_isready -U postgres;
do
  echo "Waiting for database..."
  sleep 2
done

# Create tables
psql -U postgres -d myapp -c "
  CREATE TABLE IF NOT EXISTS users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    email VARCHAR(100)
  );
"

echo "DB_INITIALIZED=true" >> $EXEC_OUTPUT
```

--------------------------------

### Generate Number Sequence with range()

Source: https://docs.labs.instruqt.com/reference/functions/collection

Generates a sequence of numbers. Can specify start, limit, and step.

```plaintext
range(limit)
range(start, limit)
range(start, limit, step)
```

```plaintext
range(3)                               # Returns: [0, 1, 2]
range(1, 4)                            # Returns: [1, 2, 3]
range(0, 10, 2)                        # Returns: [0, 2, 4, 6, 8]
range(5, 0, -1)                        # Returns: [5, 4, 3, 2, 1]
```
Tokens:
Raw