From f6d24e1bc257b4f1ba53483208d9be8e1a4ff252 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Sat, 16 Dec 2023 21:12:09 +0000 Subject: [PATCH 01/21] feat(examples/templates): add GCP VM devcontainer template --- .../templates/gcp-vm-devcontainer/README.md | 64 +++++ .../templates/gcp-vm-devcontainer/main.tf | 227 ++++++++++++++++++ 2 files changed, 291 insertions(+) create mode 100644 examples/templates/gcp-vm-devcontainer/README.md create mode 100644 examples/templates/gcp-vm-devcontainer/main.tf diff --git a/examples/templates/gcp-vm-devcontainer/README.md b/examples/templates/gcp-vm-devcontainer/README.md new file mode 100644 index 0000000000000..e6850007f88c2 --- /dev/null +++ b/examples/templates/gcp-vm-devcontainer/README.md @@ -0,0 +1,64 @@ +--- +display_name: Google Compute Engine Devcontainer (Linux) +description: Provision a Devcontainer on Google Compute Engine instances as Coder workspaces +icon: ../../../site/static/icon/gcp.png +maintainer_github: coder +verified: true +tags: [vm, linux, gcp, devcontainer] +--- + +# Remote Development in a Devcontainer on Google Compute Engine + +## Prerequisites + +### Authentication + +This template assumes that coderd is run in an environment that is authenticated +with Google Cloud. For example, run `gcloud auth application-default login` to +import credentials on the system and user running coderd. For other ways to +authenticate [consult the Terraform +docs](https://registry.terraform.io/providers/hashicorp/google/latest/docs/guides/getting_started#adding-credentials). + +Coder requires a Google Cloud Service Account to provision workspaces. To create +a service account: + +1. Navigate to the [CGP + console](https://console.cloud.google.com/projectselector/iam-admin/serviceaccounts/create), + and select your Cloud project (if you have more than one project associated + with your account) + +1. Provide a service account name (this name is used to generate the service + account ID) + +1. Click **Create and continue**, and choose the following IAM roles to grant to + the service account: + + - Compute Admin + - Service Account User + + Click **Continue**. + +1. Click on the created key, and navigate to the **Keys** tab. + +1. Click **Add key** > **Create new key**. + +1. Generate a **JSON private key**, which will be what you provide to Coder + during the setup process. + +## Architecture + +This template provisions the following resources: + +- GCP VM (persistent) +- GCP Disk (persistent, mounted to root) + +Coder persists the root volume. The full filesystem is preserved when the workspace restarts. See this [community example](https://github.com/bpmct/coder-templates/tree/main/aws-linux-ephemeral) of an ephemeral AWS instance. + +> **Note** +> This template is designed to be a starting point! Edit the Terraform to extend the template to support your use case. + +## code-server + +`code-server` is installed via the `startup_script` argument in the `coder_agent` +resource block. The `coder_app` resource is defined to access `code-server` through +the dashboard UI over `localhost:13337`. diff --git a/examples/templates/gcp-vm-devcontainer/main.tf b/examples/templates/gcp-vm-devcontainer/main.tf new file mode 100644 index 0000000000000..aacf4db7bd875 --- /dev/null +++ b/examples/templates/gcp-vm-devcontainer/main.tf @@ -0,0 +1,227 @@ +terraform { + required_providers { + coder = { + source = "coder/coder" + } + google = { + source = "hashicorp/google" + } + } +} + +provider "coder" { +} + +variable "project_id" { + description = "Which Google Compute Project should your workspace live in?" +} + +data "coder_parameter" "zone" { + name = "zone" + display_name = "Zone" + description = "Which zone should your workspace live in?" + type = "string" + icon = "/emojis/1f30e.png" + default = "us-central1-a" + mutable = false + option { + name = "North America (Northeast)" + value = "northamerica-northeast1-a" + icon = "/emojis/1f1fa-1f1f8.png" + } + option { + name = "North America (Central)" + value = "us-central1-a" + icon = "/emojis/1f1fa-1f1f8.png" + } + option { + name = "North America (West)" + value = "us-west2-c" + icon = "/emojis/1f1fa-1f1f8.png" + } + option { + name = "Europe (West)" + value = "europe-west4-b" + icon = "/emojis/1f1ea-1f1fa.png" + } + option { + name = "South America (East)" + value = "southamerica-east1-a" + icon = "/emojis/1f1e7-1f1f7.png" + } +} + +provider "google" { + zone = data.coder_parameter.zone.value + project = var.project_id +} + +data "google_compute_default_service_account" "default" { +} + +data "coder_workspace" "me" { +} + +resource "google_compute_disk" "root" { + name = "coder-${data.coder_workspace.me.id}-root" + type = "pd-ssd" + zone = data.coder_parameter.zone.value + image = "debian-cloud/debian-12" + lifecycle { + ignore_changes = [name, image] + } +} + +data "coder_parameter" "repo_url" { + name = "repo_url" + display_name = "Repository URL" + default = "https://github.com/coder/envbuilder-starter-devcontainer" + description = "Repository URL" + mutable = true +} + +resource "coder_agent" "dev" { + count = data.coder_workspace.me.start_count + arch = "amd64" + auth = "token" + os = "linux" + dir = "/worskpaces" + connection_timeout = 0 + startup_script_timeout = 180 + startup_script = <<-EOT + set -e + + # install and start code-server + curl -fsSL https://code-server.dev/install.sh | sh -s -- --method=standalone --prefix=/tmp/code-server + /tmp/code-server/bin/code-server --auth none --port 13337 >/tmp/code-server.log 2>&1 & + EOT + + metadata { + key = "cpu" + display_name = "CPU Usage" + interval = 5 + timeout = 5 + script = "coder stat cpu" + } + metadata { + key = "memory" + display_name = "Memory Usage" + interval = 5 + timeout = 5 + script = "coder stat mem" + } + metadata { + key = "disk" + display_name = "Disk Usage" + interval = 5 + timeout = 5 + script = "coder stat disk" + } +} + +resource "coder_app" "code-server" { + count = data.coder_workspace.me.start_count + agent_id = coder_agent.dev[0].id + slug = "code-server" + display_name = "code-server" + icon = "/icon/code.svg" + url = "http://localhost:13337?folder=/home/coder" + subdomain = false + share = "owner" + + healthcheck { + url = "http://localhost:13337/healthz" + interval = 3 + threshold = 10 + } +} + +resource "google_compute_instance" "vm" { + zone = data.coder_parameter.zone.value + name = "coder-${lower(data.coder_workspace.me.owner)}-${lower(data.coder_workspace.me.name)}-root" + machine_type = "e2-medium" + # data.coder_workspace.me.owner == "default" is a workaround to suppress error in the terraform plan phase while creating a new workspace. + desired_status = (data.coder_workspace.me.owner == "default" || data.coder_workspace.me.start_count == 1) ? "RUNNING" : "TERMINATED" + + network_interface { + network = "default" + access_config { + // Ephemeral public IP + } + } + + boot_disk { + auto_delete = false + source = google_compute_disk.root.name + } + + service_account { + email = data.google_compute_default_service_account.default.email + scopes = ["cloud-platform"] + } + + metadata = { + # The startup script runs as root with no $HOME environment set up, so instead of directly + # running the agent init script, create a user (with a homedir, default shell and sudo + # permissions) and execute the init script as that user. + startup-script = <<-META + #!/usr/bin/env sh + set -eux + + # If user does not exist, create it and set up passwordless sudo + if ! id -u "${local.linux_user}" >/dev/null 2>&1; then + useradd -m -s /bin/bash "${local.linux_user}" + echo "${local.linux_user} ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/coder-user + fi + + # Check for Docker, install if not present + if ! command -v docker &> /dev/null + then + echo "Docker not found, installing..." + curl -fsSL https://get.docker.com -o get-docker.sh && sudo sh get-docker.sh 2>&1 >/dev/null + sudo usermod -aG docker ${local.linux_user} + newgrp docker + else + echo "Docker is already installed." + fi + # Start envbuilder + docker run --rm \ + -v /tmp/envbuilder:/workspaces \ + -e CODER_AGENT_TOKEN="${try(coder_agent.dev[0].token, "")}" \ + -e CODER_AGENT_URL="${data.coder_workspace.me.access_url}" \ + -e GIT_URL="${data.coder_parameter.repo_url.value}" \ + -e INIT_SCRIPT="echo ${base64encode(try(coder_agent.dev[0].init_script, ""))} | base64 -d | sh" \ + -e FALLBACK_IMAGE="codercom/enterprise-base:ubuntu" \ + ghcr.io/coder/envbuilder + META + } +} + +locals { + # Ensure Coder username is a valid Linux username + linux_user = lower(substr(data.coder_workspace.me.owner, 0, 32)) +} + +resource "coder_metadata" "workspace_info" { + count = data.coder_workspace.me.start_count + resource_id = google_compute_instance.vm.id + + item { + key = "type" + value = google_compute_instance.vm.machine_type + } + + item { + key = "zone" + value = data.coder_parameter.zone.value + } +} + +resource "coder_metadata" "home_info" { + resource_id = google_compute_disk.root.id + + item { + key = "size" + value = "${google_compute_disk.root.size} GiB" + } +} From a49df653202b588087126159f73c614d2cdae0c6 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Sun, 17 Dec 2023 16:29:55 +0300 Subject: [PATCH 02/21] use zone in provider only --- examples/templates/gcp-vm-devcontainer/main.tf | 2 -- 1 file changed, 2 deletions(-) diff --git a/examples/templates/gcp-vm-devcontainer/main.tf b/examples/templates/gcp-vm-devcontainer/main.tf index aacf4db7bd875..5c21d57b38caa 100644 --- a/examples/templates/gcp-vm-devcontainer/main.tf +++ b/examples/templates/gcp-vm-devcontainer/main.tf @@ -65,7 +65,6 @@ data "coder_workspace" "me" { resource "google_compute_disk" "root" { name = "coder-${data.coder_workspace.me.id}-root" type = "pd-ssd" - zone = data.coder_parameter.zone.value image = "debian-cloud/debian-12" lifecycle { ignore_changes = [name, image] @@ -137,7 +136,6 @@ resource "coder_app" "code-server" { } resource "google_compute_instance" "vm" { - zone = data.coder_parameter.zone.value name = "coder-${lower(data.coder_workspace.me.owner)}-${lower(data.coder_workspace.me.name)}-root" machine_type = "e2-medium" # data.coder_workspace.me.owner == "default" is a workaround to suppress error in the terraform plan phase while creating a new workspace. From 0d37ff90cc493122d2842dc8d0b0c583aa2a92af Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Sun, 17 Dec 2023 16:53:14 +0300 Subject: [PATCH 03/21] move code-server to module --- .../templates/gcp-vm-devcontainer/main.tf | 29 ++++--------------- 1 file changed, 5 insertions(+), 24 deletions(-) diff --git a/examples/templates/gcp-vm-devcontainer/main.tf b/examples/templates/gcp-vm-devcontainer/main.tf index 5c21d57b38caa..ccd7b778d36dc 100644 --- a/examples/templates/gcp-vm-devcontainer/main.tf +++ b/examples/templates/gcp-vm-devcontainer/main.tf @@ -86,15 +86,7 @@ resource "coder_agent" "dev" { os = "linux" dir = "/worskpaces" connection_timeout = 0 - startup_script_timeout = 180 - startup_script = <<-EOT - set -e - - # install and start code-server - curl -fsSL https://code-server.dev/install.sh | sh -s -- --method=standalone --prefix=/tmp/code-server - /tmp/code-server/bin/code-server --auth none --port 13337 >/tmp/code-server.log 2>&1 & - EOT - + metadata { key = "cpu" display_name = "CPU Usage" @@ -118,21 +110,10 @@ resource "coder_agent" "dev" { } } -resource "coder_app" "code-server" { - count = data.coder_workspace.me.start_count - agent_id = coder_agent.dev[0].id - slug = "code-server" - display_name = "code-server" - icon = "/icon/code.svg" - url = "http://localhost:13337?folder=/home/coder" - subdomain = false - share = "owner" - - healthcheck { - url = "http://localhost:13337/healthz" - interval = 3 - threshold = 10 - } +module "code-server" { + count = data.coder_workspace.me.start_count + source = "https://registry.coder.com/modules/code-server" + agent_id = coder_agent.dev[0].id } resource "google_compute_instance" "vm" { From 7c3f646a540852dd09e761a296dda27059f01880 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Sun, 17 Dec 2023 16:54:02 +0300 Subject: [PATCH 04/21] Update README.md --- examples/templates/gcp-vm-devcontainer/README.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/examples/templates/gcp-vm-devcontainer/README.md b/examples/templates/gcp-vm-devcontainer/README.md index e6850007f88c2..d0370080b9815 100644 --- a/examples/templates/gcp-vm-devcontainer/README.md +++ b/examples/templates/gcp-vm-devcontainer/README.md @@ -59,6 +59,4 @@ Coder persists the root volume. The full filesystem is preserved when the worksp ## code-server -`code-server` is installed via the `startup_script` argument in the `coder_agent` -resource block. The `coder_app` resource is defined to access `code-server` through -the dashboard UI over `localhost:13337`. +`code-server` is installed via the [`code-server`](https://registry.coder.com/modules/code-server) registry module. For a list of all modules and templates pplease check [Coder Registry](https://registry.coder.com). From 2352c348f0d8208f127aae30725fae8bc12c6b2c Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Sun, 17 Dec 2023 14:00:32 +0000 Subject: [PATCH 05/21] `make fmt` --- examples/templates/gcp-vm-devcontainer/main.tf | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/examples/templates/gcp-vm-devcontainer/main.tf b/examples/templates/gcp-vm-devcontainer/main.tf index ccd7b778d36dc..ae91499b505d8 100644 --- a/examples/templates/gcp-vm-devcontainer/main.tf +++ b/examples/templates/gcp-vm-devcontainer/main.tf @@ -80,13 +80,13 @@ data "coder_parameter" "repo_url" { } resource "coder_agent" "dev" { - count = data.coder_workspace.me.start_count - arch = "amd64" - auth = "token" - os = "linux" - dir = "/worskpaces" - connection_timeout = 0 - + count = data.coder_workspace.me.start_count + arch = "amd64" + auth = "token" + os = "linux" + dir = "/worskpaces" + connection_timeout = 0 + metadata { key = "cpu" display_name = "CPU Usage" @@ -111,8 +111,8 @@ resource "coder_agent" "dev" { } module "code-server" { - count = data.coder_workspace.me.start_count - source = "https://registry.coder.com/modules/code-server" + count = data.coder_workspace.me.start_count + source = "https://registry.coder.com/modules/code-server" agent_id = coder_agent.dev[0].id } From 471ba6934bb1e5f2f19da9d0dd93aef6da50e469 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Sun, 17 Dec 2023 14:03:11 +0000 Subject: [PATCH 06/21] rename directory --- .../templates/{gcp-vm-devcontainer => gcp-devcontainer}/README.md | 0 .../templates/{gcp-vm-devcontainer => gcp-devcontainer}/main.tf | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename examples/templates/{gcp-vm-devcontainer => gcp-devcontainer}/README.md (100%) rename examples/templates/{gcp-vm-devcontainer => gcp-devcontainer}/main.tf (100%) diff --git a/examples/templates/gcp-vm-devcontainer/README.md b/examples/templates/gcp-devcontainer/README.md similarity index 100% rename from examples/templates/gcp-vm-devcontainer/README.md rename to examples/templates/gcp-devcontainer/README.md diff --git a/examples/templates/gcp-vm-devcontainer/main.tf b/examples/templates/gcp-devcontainer/main.tf similarity index 100% rename from examples/templates/gcp-vm-devcontainer/main.tf rename to examples/templates/gcp-devcontainer/main.tf From ee576624a9595d9c50e7503bb432c6c6e3a055c3 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Mon, 18 Dec 2023 14:27:45 +0300 Subject: [PATCH 07/21] Update README.md --- examples/templates/gcp-devcontainer/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/templates/gcp-devcontainer/README.md b/examples/templates/gcp-devcontainer/README.md index d0370080b9815..b782f072bd311 100644 --- a/examples/templates/gcp-devcontainer/README.md +++ b/examples/templates/gcp-devcontainer/README.md @@ -1,5 +1,5 @@ --- -display_name: Google Compute Engine Devcontainer (Linux) +display_name: Google Compute Engine Devcontainer description: Provision a Devcontainer on Google Compute Engine instances as Coder workspaces icon: ../../../site/static/icon/gcp.png maintainer_github: coder From cd4e2dc7473d2a5386d5375a7dd5ea5d76e5bc96 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Mon, 18 Dec 2023 14:28:48 +0300 Subject: [PATCH 08/21] Update README.md --- examples/templates/gcp-devcontainer/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/templates/gcp-devcontainer/README.md b/examples/templates/gcp-devcontainer/README.md index b782f072bd311..6b56acc417176 100644 --- a/examples/templates/gcp-devcontainer/README.md +++ b/examples/templates/gcp-devcontainer/README.md @@ -1,5 +1,5 @@ --- -display_name: Google Compute Engine Devcontainer +display_name: Google Compute Engine (Devcontainer) description: Provision a Devcontainer on Google Compute Engine instances as Coder workspaces icon: ../../../site/static/icon/gcp.png maintainer_github: coder From eff8265384419f643856e0b078cedddad336f051 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Tue, 19 Dec 2023 22:46:29 +0300 Subject: [PATCH 09/21] Update README.md --- examples/templates/gcp-devcontainer/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/templates/gcp-devcontainer/README.md b/examples/templates/gcp-devcontainer/README.md index 6b56acc417176..6141d8affd9db 100644 --- a/examples/templates/gcp-devcontainer/README.md +++ b/examples/templates/gcp-devcontainer/README.md @@ -10,7 +10,7 @@ tags: [vm, linux, gcp, devcontainer] # Remote Development in a Devcontainer on Google Compute Engine ## Prerequisites - +![Architecture Diagram](./architecture.svg) ### Authentication This template assumes that coderd is run in an environment that is authenticated From 3cc7cc02ecce6735d631561bac9ebf49fc145a93 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Tue, 19 Dec 2023 22:47:31 +0300 Subject: [PATCH 10/21] Add files via upload --- examples/templates/gcp-devcontainer/architecture.svg | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 examples/templates/gcp-devcontainer/architecture.svg diff --git a/examples/templates/gcp-devcontainer/architecture.svg b/examples/templates/gcp-devcontainer/architecture.svg new file mode 100644 index 0000000000000..d1818730f8efc --- /dev/null +++ b/examples/templates/gcp-devcontainer/architecture.svg @@ -0,0 +1,8 @@ +GCPGCPHostingHostingVirtual MachineVirtual MachineLinux HardwareLinux HardwareCoder WorkspaceCoder WorkspaceDevcontainerDevcontainerenvbuilder created filesytemenvbuilder created filesytemA Clone of your repoA Clone of your repoSource codeSource codeLanguagesLanguagesPython. Go, etcPython. Go, etcToolingToolingExtensions, linting, formatting, etcExtensions, linting, formatting, etcCPUsCPUsDisk StorageDisk StorageCode EditorCode EditorVS Code DesktopVS Code DesktopLocal InstallationLocal InstallationVS Code DesktopVS Code DesktopLocal InstallationLocal Installationcode-servercode-serverA web IDEA web IDEJetBrains GatewayJetBrains GatewayLocal InstallationLocal InstallationCommand LineCommand LineSSH via Coder CLISSH via Coder CLI \ No newline at end of file From aa17cedb64ce5296a7433fefb94a2ed127c2a38e Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Tue, 19 Dec 2023 22:50:15 +0300 Subject: [PATCH 11/21] Add files via upload --- examples/templates/gcp-devcontainer/architecture.svg | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/templates/gcp-devcontainer/architecture.svg b/examples/templates/gcp-devcontainer/architecture.svg index d1818730f8efc..54efcff7a2ebb 100644 --- a/examples/templates/gcp-devcontainer/architecture.svg +++ b/examples/templates/gcp-devcontainer/architecture.svg @@ -5,4 +5,4 @@ font-weight: 500; font-style: normal; src: url("data:font/woff2;base64,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") format("woff2") -}GCPGCPHostingHostingVirtual MachineVirtual MachineLinux HardwareLinux HardwareCoder WorkspaceCoder WorkspaceDevcontainerDevcontainerenvbuilder created filesytemenvbuilder created filesytemA Clone of your repoA Clone of your repoSource codeSource codeLanguagesLanguagesPython. Go, etcPython. Go, etcToolingToolingExtensions, linting, formatting, etcExtensions, linting, formatting, etcCPUsCPUsDisk StorageDisk StorageCode EditorCode EditorVS Code DesktopVS Code DesktopLocal InstallationLocal InstallationVS Code DesktopVS Code DesktopLocal InstallationLocal Installationcode-servercode-serverA web IDEA web IDEJetBrains GatewayJetBrains GatewayLocal InstallationLocal InstallationCommand LineCommand LineSSH via Coder CLISSH via Coder CLI \ No newline at end of file +}GCPGCPHostingHostingVirtual MachineVirtual MachineLinux HardwareLinux HardwareCoder WorkspaceCoder WorkspaceDevcontainerDevcontainerenvbuilder created filesytemenvbuilder created filesytemA Clone of your repoA Clone of your repoSource codeSource codeLanguagesLanguagesPython. Go, etcPython. Go, etcToolingToolingExtensions, linting, formatting, etcExtensions, linting, formatting, etcCPUsCPUsDisk StorageDisk StorageCode EditorCode EditorVS Code DesktopVS Code DesktopLocal InstallationLocal InstallationVS Code DesktopVS Code DesktopLocal InstallationLocal Installationcode-servercode-serverA web IDEA web IDEJetBrains GatewayJetBrains GatewayLocal InstallationLocal InstallationCommand LineCommand LineSSH via Coder CLISSH via Coder CLI \ No newline at end of file From e93e7db757af64c0ef4a42b9537d53788b55aa64 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Tue, 19 Dec 2023 22:54:36 +0300 Subject: [PATCH 12/21] Add files via upload --- examples/templates/gcp-devcontainer/architecture.svg | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/templates/gcp-devcontainer/architecture.svg b/examples/templates/gcp-devcontainer/architecture.svg index 54efcff7a2ebb..9ef07abbca205 100644 --- a/examples/templates/gcp-devcontainer/architecture.svg +++ b/examples/templates/gcp-devcontainer/architecture.svg @@ -1,8 +1,8 @@ -GCPGCPHostingHostingVirtual MachineVirtual MachineLinux HardwareLinux HardwareCoder WorkspaceCoder WorkspaceDevcontainerDevcontainerenvbuilder created filesytemenvbuilder created filesytemA Clone of your repoA Clone of your repoSource codeSource codeLanguagesLanguagesPython. Go, etcPython. Go, etcToolingToolingExtensions, linting, formatting, etcExtensions, linting, formatting, etcCPUsCPUsDisk StorageDisk StorageCode EditorCode EditorVS Code DesktopVS Code DesktopLocal InstallationLocal InstallationVS Code DesktopVS Code DesktopLocal InstallationLocal Installationcode-servercode-serverA web IDEA web IDEJetBrains GatewayJetBrains GatewayLocal InstallationLocal InstallationCommand LineCommand LineSSH via Coder CLISSH via Coder CLI \ No newline at end of file From ddc8411f5973ad0300e991e9778cbe88801f38a8 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Tue, 19 Dec 2023 22:55:21 +0300 Subject: [PATCH 13/21] Update README.md --- examples/templates/gcp-devcontainer/README.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/examples/templates/gcp-devcontainer/README.md b/examples/templates/gcp-devcontainer/README.md index 6141d8affd9db..5636e7a3fb453 100644 --- a/examples/templates/gcp-devcontainer/README.md +++ b/examples/templates/gcp-devcontainer/README.md @@ -9,8 +9,10 @@ tags: [vm, linux, gcp, devcontainer] # Remote Development in a Devcontainer on Google Compute Engine -## Prerequisites ![Architecture Diagram](./architecture.svg) + +## Prerequisites + ### Authentication This template assumes that coderd is run in an environment that is authenticated From aa087512259c33ff68a738c305ebfb5120d1e846 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Wed, 20 Dec 2023 09:32:01 +0300 Subject: [PATCH 14/21] remove aws template link --- examples/templates/gcp-devcontainer/README.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/templates/gcp-devcontainer/README.md b/examples/templates/gcp-devcontainer/README.md index 5636e7a3fb453..bbf33779dd129 100644 --- a/examples/templates/gcp-devcontainer/README.md +++ b/examples/templates/gcp-devcontainer/README.md @@ -54,11 +54,11 @@ This template provisions the following resources: - GCP VM (persistent) - GCP Disk (persistent, mounted to root) -Coder persists the root volume. The full filesystem is preserved when the workspace restarts. See this [community example](https://github.com/bpmct/coder-templates/tree/main/aws-linux-ephemeral) of an ephemeral AWS instance. +Coder persists the root volume. The full filesystem is preserved when the workspace restarts. > **Note** > This template is designed to be a starting point! Edit the Terraform to extend the template to support your use case. ## code-server -`code-server` is installed via the [`code-server`](https://registry.coder.com/modules/code-server) registry module. For a list of all modules and templates pplease check [Coder Registry](https://registry.coder.com). +`code-server` is installed via the [`code-server`](https://registry.coder.com/modules/code-server) registry module. Please check [Coder Registry](https://registry.coder.com) for a list of all modules and templates. From 49551658561839a69d00609de80507de395c03e4 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Wed, 20 Dec 2023 10:29:20 +0300 Subject: [PATCH 15/21] test GFM --- examples/templates/gcp-devcontainer/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/templates/gcp-devcontainer/README.md b/examples/templates/gcp-devcontainer/README.md index bbf33779dd129..20f915a4a2227 100644 --- a/examples/templates/gcp-devcontainer/README.md +++ b/examples/templates/gcp-devcontainer/README.md @@ -56,7 +56,7 @@ This template provisions the following resources: Coder persists the root volume. The full filesystem is preserved when the workspace restarts. -> **Note** +> [!NOTE] > This template is designed to be a starting point! Edit the Terraform to extend the template to support your use case. ## code-server From 152f46acfd75cd0f0def69488047cde9656caf40 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Wed, 20 Dec 2023 10:58:25 +0300 Subject: [PATCH 16/21] Update README.md --- examples/templates/gcp-devcontainer/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/templates/gcp-devcontainer/README.md b/examples/templates/gcp-devcontainer/README.md index 20f915a4a2227..bbf33779dd129 100644 --- a/examples/templates/gcp-devcontainer/README.md +++ b/examples/templates/gcp-devcontainer/README.md @@ -56,7 +56,7 @@ This template provisions the following resources: Coder persists the root volume. The full filesystem is preserved when the workspace restarts. -> [!NOTE] +> **Note** > This template is designed to be a starting point! Edit the Terraform to extend the template to support your use case. ## code-server From f21400123ce18c4088f6b35fe25174f4ffaf4a1f Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Thu, 21 Dec 2023 15:22:23 +0300 Subject: [PATCH 17/21] polish up --- examples/templates/gcp-devcontainer/main.tf | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/examples/templates/gcp-devcontainer/main.tf b/examples/templates/gcp-devcontainer/main.tf index ae91499b505d8..00323ec20a246 100644 --- a/examples/templates/gcp-devcontainer/main.tf +++ b/examples/templates/gcp-devcontainer/main.tf @@ -84,7 +84,7 @@ resource "coder_agent" "dev" { arch = "amd64" auth = "token" os = "linux" - dir = "/worskpaces" + dir = "/workspaces/${trimsuffix(basename(data.coder_parameter.repo_url.value), ".git")}" connection_timeout = 0 metadata { @@ -165,7 +165,8 @@ resource "google_compute_instance" "vm" { fi # Start envbuilder docker run --rm \ - -v /tmp/envbuilder:/workspaces \ + -h ${lower(data.coder_workspace.me.name)} \ + -v /home/${local.linux_user}/envbuilder:/workspaces \ -e CODER_AGENT_TOKEN="${try(coder_agent.dev[0].token, "")}" \ -e CODER_AGENT_URL="${data.coder_workspace.me.access_url}" \ -e GIT_URL="${data.coder_parameter.repo_url.value}" \ From 1314f2efe52409fb28ce340aabe1478f01d2c7c9 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Thu, 21 Dec 2023 15:24:28 +0300 Subject: [PATCH 18/21] set hotsname to workspace name --- examples/templates/aws-devcontainer/main.tf | 1 + 1 file changed, 1 insertion(+) diff --git a/examples/templates/aws-devcontainer/main.tf b/examples/templates/aws-devcontainer/main.tf index 74d380723a8e0..664ace2713798 100644 --- a/examples/templates/aws-devcontainer/main.tf +++ b/examples/templates/aws-devcontainer/main.tf @@ -145,6 +145,7 @@ locals { # Start envbuilder docker run --rm \ + -h ${lower(data.coder_workspace.me.name)} \ -v /home/${local.linux_user}/envbuilder:/workspaces \ -e CODER_AGENT_TOKEN="${try(coder_agent.dev[0].token, "")}" \ -e CODER_AGENT_URL="${data.coder_workspace.me.access_url}" \ From ee96c0ef33eda151ba216e9a7219f6d276e341bd Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Thu, 21 Dec 2023 15:28:20 +0300 Subject: [PATCH 19/21] add to starter templates --- examples/examples.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/examples/examples.go b/examples/examples.go index 5603f7db26ba5..9672f52781dc2 100644 --- a/examples/examples.go +++ b/examples/examples.go @@ -23,11 +23,13 @@ var ( // Only some templates are embedded that we want to display inside the UI. // The metadata in examples.gen.json is generated via scripts/examplegen. //go:embed examples.gen.json + //go:embed templates/aws-devcontainer //go:embed templates/aws-linux //go:embed templates/aws-windows //go:embed templates/azure-linux //go:embed templates/do-linux //go:embed templates/docker + //go:embed templates/gcp-devcontainer //go:embed templates/gcp-linux //go:embed templates/gcp-vm-container //go:embed templates/gcp-windows From 76a0505fd05b60206b7db84941e1410397f0fa3f Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Thu, 21 Dec 2023 12:34:33 +0000 Subject: [PATCH 20/21] `make gen` --- docs/cli/templates_init.md | 6 +++--- examples/examples.gen.json | 29 +++++++++++++++++++++++++++++ 2 files changed, 32 insertions(+), 3 deletions(-) diff --git a/docs/cli/templates_init.md b/docs/cli/templates_init.md index fb5df7fbfaf6f..d26a8cb857f81 100644 --- a/docs/cli/templates_init.md +++ b/docs/cli/templates_init.md @@ -14,8 +14,8 @@ coder templates init [flags] [directory] ### --id -| | | -| ---- | -------------------- | ----------- | ----------- | -------- | ------ | --------- | ---------------- | ----------- | ---------- | -------------------- | -| Type | enum[aws-linux | aws-windows | azure-linux | do-linux | docker | gcp-linux | gcp-vm-container | gcp-windows | kubernetes | nomad-docker] | +| | | +| ---- | --------------------------- | --------- | ----------- | ----------- | -------- | ------ | ---------------- | --------- | ---------------- | ----------- | ---------- | -------------------- | +| Type | enum[aws-devcontainer | aws-linux | aws-windows | azure-linux | do-linux | docker | gcp-devcontainer | gcp-linux | gcp-vm-container | gcp-windows | kubernetes | nomad-docker] | Specify a given example template by ID. diff --git a/examples/examples.gen.json b/examples/examples.gen.json index cff675d1adcbf..d216581c7c116 100644 --- a/examples/examples.gen.json +++ b/examples/examples.gen.json @@ -1,5 +1,20 @@ // Code generated by examplegen. DO NOT EDIT. [ + { + "id": "aws-devcontainer", + "url": "", + "name": "AWS EC2 (Devcontainer)", + "description": "Provision AWS EC2 VMs with a devcontainer as Coder workspaces", + "icon": "/icon/aws.png", + "tags": [ + "vm", + "linux", + "aws", + "persistent", + "devcontainer" + ], + "markdown": "\n# Remote Development on AWS EC2 VMs using a Devcontainer\n\nProvision AWS EC2 VMs as [Coder workspaces](https://coder.com/docs/v2/latest) with this example template.\n![Architecture Diagram](./architecture.svg)\n\n\u003c!-- TODO: Add screenshot --\u003e\n\n## Prerequisites\n\n### Authentication\n\nBy default, this template authenticates to AWS using the provider's default [authentication methods](https://registry.terraform.io/providers/hashicorp/aws/latest/docs#authentication-and-configuration).\n\nThe simplest way (without making changes to the template) is via environment variables (e.g. `AWS_ACCESS_KEY_ID`) or a [credentials file](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-format). If you are running Coder on a VM, this file must be in `/home/coder/aws/credentials`.\n\nTo use another [authentication method](https://registry.terraform.io/providers/hashicorp/aws/latest/docs#authentication), edit the template.\n\n## Required permissions / policy\n\nThe following sample policy allows Coder to create EC2 instances and modify\ninstances provisioned by Coder:\n\n```json\n{\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n \"Sid\": \"VisualEditor0\",\n \"Effect\": \"Allow\",\n \"Action\": [\n \"ec2:GetDefaultCreditSpecification\",\n \"ec2:DescribeIamInstanceProfileAssociations\",\n \"ec2:DescribeTags\",\n \"ec2:DescribeInstances\",\n \"ec2:DescribeInstanceTypes\",\n \"ec2:CreateTags\",\n \"ec2:RunInstances\",\n \"ec2:DescribeInstanceCreditSpecifications\",\n \"ec2:DescribeImages\",\n \"ec2:ModifyDefaultCreditSpecification\",\n \"ec2:DescribeVolumes\"\n ],\n \"Resource\": \"*\"\n },\n {\n \"Sid\": \"CoderResources\",\n \"Effect\": \"Allow\",\n \"Action\": [\n \"ec2:DescribeInstanceAttribute\",\n \"ec2:UnmonitorInstances\",\n \"ec2:TerminateInstances\",\n \"ec2:StartInstances\",\n \"ec2:StopInstances\",\n \"ec2:DeleteTags\",\n \"ec2:MonitorInstances\",\n \"ec2:CreateTags\",\n \"ec2:RunInstances\",\n \"ec2:ModifyInstanceAttribute\",\n \"ec2:ModifyInstanceCreditSpecification\"\n ],\n \"Resource\": \"arn:aws:ec2:*:*:instance/*\",\n \"Condition\": {\n \"StringEquals\": {\n \"aws:ResourceTag/Coder_Provisioned\": \"true\"\n }\n }\n }\n ]\n}\n```\n\n## Architecture\n\nThis template provisions the following resources:\n\n- AWS Instance\n\nCoder uses `aws_ec2_instance_state` to start and stop the VM. This example template is fully persistent, meaning the full filesystem is preserved when the workspace restarts. See this [community example](https://github.com/bpmct/coder-templates/tree/main/aws-linux-ephemeral) of an ephemeral AWS instance.\n\n\u003e **Note**\n\u003e This template is designed to be a starting point! Edit the Terraform to extend the template to support your use case.\n\n## code-server\n\n`code-server` is installed via the [`code-server`](https://registry.coder.com/modules/code-server) registry module. For a list of all modules and templates pplease check [Coder Registry](https://registry.coder.com).\n" + }, { "id": "aws-linux", "url": "", @@ -65,6 +80,20 @@ ], "markdown": "\n# Remote Development on Docker Containers\n\nProvision Docker containers as [Coder workspaces](https://coder.com/docs/coder-v2/latest) with this example template.\n\n\u003c!-- TODO: Add screenshot --\u003e\n\n## Prerequisites\n\n### Infrastructure\n\nThe VM you run Coder on must have a running Docker socket and the `coder` user must be added to the Docker group:\n\n```sh\n# Add coder user to Docker group\nsudo adduser coder docker\n\n# Restart Coder server\nsudo systemctl restart coder\n\n# Test Docker\nsudo -u coder docker ps\n```\n\n## Architecture\n\nThis template provisions the following resources:\n\n- Docker image (built by Docker socket and kept locally)\n- Docker container pod (ephemeral)\n- Docker volume (persistent on `/home/coder`)\n\nThis means, when the workspace restarts, any tools or files outside of the home directory are not persisted. To pre-bake tools into the workspace (e.g. `python3`), modify the container image. Alternatively, individual developers can [personalize](https://coder.com/docs/v2/latest/dotfiles) their workspaces with dotfiles.\n\n\u003e **Note**\n\u003e This template is designed to be a starting point! Edit the Terraform to extend the template to support your use case.\n\n### Editing the image\n\nEdit the `Dockerfile` and run `coder templates push` to update workspaces.\n" }, + { + "id": "gcp-devcontainer", + "url": "", + "name": "Google Compute Engine (Devcontainer)", + "description": "Provision a Devcontainer on Google Compute Engine instances as Coder workspaces", + "icon": "/icon/gcp.png", + "tags": [ + "vm", + "linux", + "gcp", + "devcontainer" + ], + "markdown": "\n# Remote Development in a Devcontainer on Google Compute Engine\n\n![Architecture Diagram](./architecture.svg)\n\n## Prerequisites\n\n### Authentication\n\nThis template assumes that coderd is run in an environment that is authenticated\nwith Google Cloud. For example, run `gcloud auth application-default login` to\nimport credentials on the system and user running coderd. For other ways to\nauthenticate [consult the Terraform\ndocs](https://registry.terraform.io/providers/hashicorp/google/latest/docs/guides/getting_started#adding-credentials).\n\nCoder requires a Google Cloud Service Account to provision workspaces. To create\na service account:\n\n1. Navigate to the [CGP\n console](https://console.cloud.google.com/projectselector/iam-admin/serviceaccounts/create),\n and select your Cloud project (if you have more than one project associated\n with your account)\n\n1. Provide a service account name (this name is used to generate the service\n account ID)\n\n1. Click **Create and continue**, and choose the following IAM roles to grant to\n the service account:\n\n - Compute Admin\n - Service Account User\n\n Click **Continue**.\n\n1. Click on the created key, and navigate to the **Keys** tab.\n\n1. Click **Add key** \u003e **Create new key**.\n\n1. Generate a **JSON private key**, which will be what you provide to Coder\n during the setup process.\n\n## Architecture\n\nThis template provisions the following resources:\n\n- GCP VM (persistent)\n- GCP Disk (persistent, mounted to root)\n\nCoder persists the root volume. The full filesystem is preserved when the workspace restarts.\n\n\u003e **Note**\n\u003e This template is designed to be a starting point! Edit the Terraform to extend the template to support your use case.\n\n## code-server\n\n`code-server` is installed via the [`code-server`](https://registry.coder.com/modules/code-server) registry module. Please check [Coder Registry](https://registry.coder.com) for a list of all modules and templates.\n" + }, { "id": "gcp-linux", "url": "", From b9fb206e844977dcbb48462cff80149fb7ea1277 Mon Sep 17 00:00:00 2001 From: Muhammad Atif Ali Date: Thu, 21 Dec 2023 12:51:48 +0000 Subject: [PATCH 21/21] `make update-golden-files` --- cli/testdata/coder_templates_init_--help.golden | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cli/testdata/coder_templates_init_--help.golden b/cli/testdata/coder_templates_init_--help.golden index 6d32c3a31009c..9f7289407caf2 100644 --- a/cli/testdata/coder_templates_init_--help.golden +++ b/cli/testdata/coder_templates_init_--help.golden @@ -6,7 +6,7 @@ USAGE: Get started with a templated template. OPTIONS: - --id aws-linux|aws-windows|azure-linux|do-linux|docker|gcp-linux|gcp-vm-container|gcp-windows|kubernetes|nomad-docker + --id aws-devcontainer|aws-linux|aws-windows|azure-linux|do-linux|docker|gcp-devcontainer|gcp-linux|gcp-vm-container|gcp-windows|kubernetes|nomad-docker Specify a given example template by ID. ———