)

vardefaultDevUser= codersdk.CreateFirstUserRequest{

Email:"admin@coder.com",

Username:"developer",

Password:"password",

OrganizationName:"acme-corp",

}

funcserver()*cobra.Command {

var (

iferr!=nil {

returnxerrors.Errorf("create first user: %w",err)

}

_,_=fmt.Fprintf(cmd.ErrOrStderr(),"email: %s\n",defaultDevUser.Email)

_,_=fmt.Fprintf(cmd.ErrOrStderr(),"password: %s\n",defaultDevUser.Password)

_,_=fmt.Fprintln(cmd.ErrOrStderr())

_,_=fmt.Fprintf(cmd.ErrOrStderr(),cliui.Styles.Wrap.Render(`Started in dev mode. All data is in-memory! `+cliui.Styles.Bold.Render("Do not use in production")+`. Press `+

cliui.Styles.Field.Render("ctrl+c")+` to clean up provisioned infrastructure.`)+"\n\n")

}

funccreateFirstUser(cmd*cobra.Command,client*codersdk.Client,cfg config.Root)error {

_,err:=client.CreateFirstUser(cmd.Context(), codersdk.CreateFirstUserRequest{

Email:"admin@coder.com",

Username:"developer",

Password:"password",

OrganizationName:"acme-corp",

})

_,err:=client.CreateFirstUser(cmd.Context(),defaultDevUser)

iferr!=nil {

returnxerrors.Errorf("create first user: %w",err)

}

token,err:=client.LoginWithPassword(cmd.Context(), codersdk.LoginWithPasswordRequest{

Email:"admin@coder.com",

Password:"password",

Email:defaultDevUser.Email,

Password:defaultDevUser.Password,

})

iferr!=nil {

returnxerrors.Errorf("login with first user: %w",err)

package cli_test

import (

ctx,cancelFunc:=context.WithCancel(context.Background())

defercancelFunc()

root,cfg:=clitest.New(t,"server","--dev","--skip-tunnel","--address",":0")

varstdoutBuf bytes.Buffer

root.SetOutput(&stdoutBuf)

gofunc() {

err:=root.ExecuteContext(ctx)

require.ErrorIs(t,err,context.Canceled)

assert.Contains(t,stdoutBuf.String(),wantEmail,"expected output %q; got no match",wantEmail)

assert.Contains(t,stdoutBuf.String(),wantPassword,"expected output %q; got no match",wantPassword)

}()

require.Eventually(t,func()bool {

`coder` requires Go 1.18+, Node 14+, and GNU Make.

Coder requires Go 1.18+, Node 14+, and GNU Make.

Thefollowing`make` commands and scripts used in development:

Use thefollowing`make` commands and scripts in development:

-`make bin` builds binaries

-`make install` installs binaries to`$GOPATH/bin`

-`make release` dry-runs a new release

-`./develop.sh` hot-reloads forfrontend development

-`make release` dryruns a new release

-`./develop.sh` hotreloads forfront-end development

Contributions must adhere to[Effective Go](https://go.dev/doc/effective_go). Linting rules should

be preferred over documenting styles (run ours with`make lint`); humans are error prone!

Contributions must adhere to the guidelines outlined in[Effective

Go](https://go.dev/doc/effective_go). We prefer linting rules over documenting

styles (run ours with`make lint`); humans are error-prone!

Read[Go's Code Review Comments Wiki](https://github.com/golang/go/wiki/CodeReviewComments) to find

Read[Go's Code Review Comments

Wiki](https://github.com/golang/go/wiki/CodeReviewComments) for information on

common comments made during reviews of Go code.

Coders write packages that are used during implementation. It's difficult to validate whether an

abstraction is valid until it's checked against an implementation. This results in a larger

changeset but provides reviewers with an educated perspective on the contribution.

Coder writes packages that are used during implementation. It isn't easy to

validate whether an abstraction is valid until it's checked against an

implementation. This results in a larger changeset, but it provides reviewers

with a holistic perspective regarding the contribution.

Coders value thorough reviews. Think of each review comment like a ticket: you are expected to

somehow "close" it by acting on it, either by implementing the suggestion or convincing the reviewer

otherwise.

After you update the change, go through the review comments and make sure to reply to every one. You

can click the "Done" button to reply indicating that you've implemented the reviewer's suggestion;

otherwise, click on "Reply" and explain why you have not, or what you have done instead.

Coder values thorough reviews. For each review comment that you receive, please

"close" it by implementing the suggestion or providing an explanation on why the

suggestion isn't the best option. Be sure to do this for each comment; you can

click**Done** to indicate that you've implemented the suggestion, or you can

add a comment explaining why you aren't implementing the suggestion (or what you

chose to implement instead).

It is perfectly normal for changes to go through several round of reviews, with one or more

reviewers making new comments every time and then waiting for an updated change before reviewing

again. All contributors, including experienced maintainers, are subject to the same review cycle;

this process is not meant to be applied selectively or discourage anyone from contribution.

It is perfectly normal for changes to go through several rounds of reviews, with

one or more reviewers making new comments every time, then waiting for an

updated change before reviewing again. All contributors, including those from

maintainers, are subject to the same review cycle; this process is not meant to

be applied selectively or to discourage anyone from contributing.

[](https://github.com/coder/coder/discussions)[](https://coder.com/community)[](https://twitter.com/coderhq)[](https://codecov.io/gh/coder/coder)

[!["GitHub

Discussions"](https://img.shields.io/badge/%20GitHub-%20Discussions-gray.svg?longCache=true&logo=github&colorB=purple)](https://github.com/coder/coder/discussions)

[!["Join us on

Slack"](https://img.shields.io/badge/join-us%20on%20slack-gray.svg?longCache=true&logo=slack&colorB=brightgreen)](https://coder.com/community)

[![Twitter

Follow](https://img.shields.io/twitter/follow/CoderHQ?label=%40CoderHQ&style=social)](https://twitter.com/coderhq)

[](https://codecov.io/gh/coder/coder)

Provision remote development environments with Terraform.

- Automate development environments for Linux, Windows, andMacOS in your cloud

- Automate development environments for Linux, Windows, andmacOS

- Start writing code with a single command

-Useone ofmany[examples](./examples)to get started

-Get started quickly usingone ofthe[examples](./examples)provided

Install[the latest release](https://github.com/coder/coder/releases).

Install[the latest release](https://github.com/coder/coder/releases) on a system with

at least 1 CPU core and 2 GB RAM.

Totinker, start with dev-mode (all data is in-memory, and is destroyed on exit):

Totest, start with devmode (all data is in-memory and is destroyed on exit):

$coder server --dev

coder server --dev

To run a production deployment with PostgreSQL:

$CODER_PG_CONNECTION_URL="postgres://<username>@<host>/<database>?password=<password>" \

CODER_PG_CONNECTION_URL="postgres://<username>@<host>/<database>?password=<password>" \

coder server

To run as a system service, install with`.deb` or`.rpm`:

To run as a system service, install with`.deb` (Debian, Ubuntu) or`.rpm`

(Fedora, CentOS, RHEL, SUSE):

$sudo vim /etc/coder.d/coder.env

$sudo service coder restart

sudo vim /etc/coder.d/coder.env

sudo service coder restart

Use`coder start --help` to get a complete list of flags and environment

variables.

In a new terminal, create a template (e.g., a template to**Develop in Linux on

Google Cloud**):

coder templates init

coder templates create

Create anewworkspace andSSH in:

Create a workspace andconnect to it via SSH:

coder workspaces create my-first-workspace

coder ssh my-first-workspace

You can edit the Terraformfroma sampleproject:

You can edit the Terraformtemplate usinga sampletemplate:

$coder templates init

$cd gcp-linux/

$vim main.tf

$coder templates update gcp-linux

coder templates init

cd gcp-linux/

vim main.tf

coder templates update gcp-linux

-[About Coder](./about.md#about-coder)

-[Why remote development](about.md#why-remote-development)

-[Why Coder](about.md#why-coder)

-[What Coder is not](about.md#what-coder-is-not)

-[Templates](./templates.md)

-[Manage templates](./templates.md#manage-templates)

-[Persistent and ephemeral

resources](./templates.md#persistent-and-ephemeral-resources)

-[Variables](./templates.md#variables)

-[Workspaces](./workspaces.md)

-[Create workspaces](./workspaces.md#create-workspaces)

-[Connect with SSH](./workspaces.md#connect-with-ssh)

-[Editors and IDEs](./workspaces.md#editors-and-ides)

-[Workspace lifecycle](./workspaces.md#workspace-lifecycle)

-[Updating workspaces](./workspaces.md#updating-workspaces)

Read the[contributing docs](./CONTRIBUTING.md).

| Name| Start Date| First PR Date|Organization| GitHub User Link|

| -------------| :--------:| :-----------:|:----------:| ------------------------------:|

| Mathias Fredriksson| 04/25/2022| 04/25/2022|[Coder](https://github.com/coder)|[mafredri](https://github.com/mafredri)|

Keeping your code secure iscore to what we do. If you find a vulnerability,

please send an email tosecurity@coder.com, and our team will respond to you.

Keeping your code secure iscentral to what we do. If you find a vulnerability,

please send an email tosecurity@coder.com.

Coder is an open source platform for creating and managing developer workspaces

on your preferred clouds and servers.

By building on top of common development interfaces (SSH) and infrastructure tools (Terraform), Coder aims to make the process of**provisioning** and**accessing** remote workspaces approachable for organizations of various sizes and stages of cloud-native maturity.

Migrating from local developer machines to workspaces hosted by cloud services

is an increasingly common solution for developers[^1] and organizations[^2]

alike. There are several benefits, including:

-**Increased speed:** Server-grade compute speeds up operations in software

development, such as IDE loading, code compilation and building, and the

running of large workloads (such as those for monolith or microservice

applications)

-**Easier environment management:** Tools such as Terraform, nix, Docker,

devcontainers, and so on make developer onboarding and the troubleshooting of

development environments easier

-**Increase security:** Centralize source code and other data onto private

servers or cloud services instead of local developer machines

-**Improved compatibility:** Remote workspaces share infrastructure

configuration with other development, staging, and production environments,

reducing configuration drift

-**Improved accessibility:** Devices such as lightweight notebooks,

Chromebooks, and iPads can connect to remote workspaces via browser-based IDEs

or remote IDE extensions

The key difference between Coder v2 and other remote IDE platforms is the added

layer of infrastructure control. This additional layer allows admins to:

- Support ARM, Windows, Linux, and macOS workspaces

- Modify pod/container specs (e.g., adding disks, managing network policies,

setting/updating environment variables)

- Use VM/dedicated workspaces, developing with Kernel features (no container

knowledge required)

- Enable persistent workspaces, which are like local machines, but faster and

hosted by a cloud service

Coder includes[production-ready templates](../examples) for use with AWS EC2,

Azure, Google Cloud, Kubernetes, and more.

- Coder is not an infrastructure as code (IaC) platform. Terraform is the first

IaC*provisioner* in Coder, allowing Coder admins to define Terraform

resources as Coder workspaces.

- Coder is not a DevOps/CI platform. Coder workspaces can follow best practices

for cloud service-based workloads, but Coder is not responsible for how you

define or deploy the software you write.

- Coder is not an online IDE. Instead, Coder supports common editors, such as VS

Code, vim, and JetBrains, over HTTPS or SSH.

- Coder is not a collaboration platform. You can use git and dedicated IDE

extensions for pull requests, code reviews, and pair programming.

- Coder is not a SaaS/fully-managed offering. You must host

Coder on a cloud service (AWS, Azure, GCP) or your private data center.

Next:[Templates](./templates.md)

[^1]: alexellis.io:[The Internet is my computer](https://blog.alexellis.io/the-internet-is-my-computer/)

[^2]: slack.engineering:[Development environments at Slack](https://slack.engineering/development-environments-at-slack)