The Go App Deploy Template for Adaptable.io makes it simple to deploy an app based on Go language Go. In just a few clicks, Adaptable deploys all the cloud-based resources you need to run your full-stack Go app, including:
- Building your app into Serverless Containers
- Fully-managed Serverless Database (MongoDB, PostgreSQL, or MS SQL Server)
- Load Balancing
- HTTPS (SSL/TLS)
»Using this template
For step-by-step instructions on how to deploy your existing Go app with this template, check out the App Guide for Deploying a Go App.
Specifies a sub-directory within your GitHub repo that will be used as the root of the app to be deployed.
Use this setting if you're deploying an app that is part of a monorepo or your app's Go source directory is not in the root of your GitHub repo.
Note that this is the directory where the Install Command, Build Command, and Start Command will be executed.
There is no access to access to anything outside the base directory during these commands, nor at runtime.
main.go in the repository root directory)
You have a monorepo with source code for multiple apps.
The Go source code for the app you want to deploy is located in your repo at
In this case, Base Directory should be set to
This setting allows you to specify the install command used to fetch dependencies prior to building your Go code.
If you have more complex requirements than a single command, write an install script, like
install.sh, make sure it is has executable permissions, and then use that as the build command.
The Install Command value will be executed as a bash shell script in the Base Directory, so you may use environment variables and other shell features.
go get (if a go.mod file is found)
This setting allows you to specify the build command to run each time a new container image is built from your app source code.
Set this setting to the command line of the command used to build your Go project.
If you have more complex requirements than a single command, write a build script, like
build.sh, make sure it is has executable permissions, and then use that as the build command.
The Build Command value will be executed as a bash shell script in the Base Directory, so you may use environment variables and other shell features.
go build -o out
Specifies the command to run to start your app. Set this to the command that runs the production (non-development) version of your app.
The Start Command value will be executed as a bash shell script in the Base Directory, so you may use environment variables and other shell features.
See Specifying a start command for more information.
If the build command is
go build -o myapp, you would set Start Command to:
»Runtime Environment Variables
You can specify your own custom environment variables that will be available to your app while it is running. For more information on setting custom environment variables, see Customizing Your App Environment.
The template also automatically provides several pre-set environment variables to your app at runtime:
ADAPTABLE_TRUST_PROXY_DEPTH: When this variable is set, it indicates that the app is behind one or more reverse proxies. The value is an integer number of proxies that your app may trust in the
X-Forwarded-ForHTTP request header. If this variable is set, the
X-Forwarded-HostHTTP request headers may also be trusted.
DATABASE_URL: This is the URL that your app should use to contact the database provisioned alongside your app. It will include the database protocol, port, and hostname, as well as the username, password, and specific database to connect to. It may also have additional query parameters containing database options. This URL can often be used directly by a library such as Sequelize. If you manually parse this URL, be aware that all special characters in each portion of the URL have been URL-encoded and should be decoded before use.
EXTERNAL_HOSTNAME: This is the externally visible host and domain name for your app.
EXTERNAL_URL: This is the externally visible URL where your app users can contact your app. This will always begin with
Apps that use a PostgreSQL database will also have the following environment variables set:
PGDATABASE: The name of the database to connect to.
PGHOST: The hostname of the database cluster.
PGPASSWORD: The password to use when connecting to the database. Note that this environment variable may contain special characters.
PGPORT: The TCP port number to connect to.
PGSSLMODE: Specifies whether to negotiate SSL/TLS with the database cluster. In Adaptable, this will always be
verify-full. Adaptable-provisioned PostgreSQL databases require the use of SSL/TLS.
PGSSLROOTCERT: Path to a file containing SSL/TLS root certificates associated with the database cluster. In order for your PostgreSQL client to verify the database cluster's certificate, you must correctly configure your PostgreSQL client to verify using this root certificate.
PGUSER: The username to use when connecting to the database.
Apps that use a Microsoft SQL Server database will also have the following environment variables set:
MSSQL_DATABASE: The name of the database to connect to.
MSSQL_HOST: The hostname of the database cluster.
MSSQL_PASSWORD: The password to use when connecting to the database. Note that this environment variable may contain special characters.
MSSQL_TCP_PORT: The TCP port number to connect to.
MSSQL_USER: The username to use when connecting to the database.
Runtime environment variables are not available during your app's build process.
»Build Environment Variables
You can specify your own custom environment variables that will be available to your app during the image build process. For more information on setting custom environment variables, see Customizing Your App Environment.
Build environment variables are only available during the build process, not during normal app runtime.
When this template is used to deploy your app, it creates the following Adaptable Cloud resources:
The first time your app is deployed, the template creates a fully-managed serverless database that your app can use to store its data.
This template supports MongoDB, PostgreSQL, and Microsoft SQL Server.
Connection information for the database is provided directly to your running app via the
DATABASE_URL environment variable.
The template creates an HTTPS load balancer that sits in front of your app. This means that your deployed app immediately supports TLS encryption and advanced protocols like HTTP/2 and HTTP/3 without having to change your app source code.
The template automatically builds your app source code from your GitHub repo into a Kubernetes-compatible container image each time you push to your selected branch on GitHub.
If your app requires custom install steps to be run during the image build process, see Install Command. If your app requires custom build steps to be run during the image build process, see Build Command. To provide environment variables that can be accessed during the image build process, see Build Environment.
After the template builds your app into a container image, it deploys that image to the Adaptable Container Service, which is a highly scalable serverless platform.
»Specifying a start command
For Adaptable to run your app, you must specify the command line that Adaptable should execute to run your app. Adaptable will look for your app's start command in a few places. It will try them in the order listed below and use the command from the first one it finds.
The start command will be executed as a bash shell script, so you may use environment variables and other shell features in each of the methods of specifying a start command below.
Start Command template setting
The easiest way to specify the start command for your app is to use the
Start Command settingof the template. You can find this setting by going to the App Status page for your app, clicking on the
Settingstab, and then clicking on
Go Settings. You can then type your app's start command into the
Start Commandbox. Then click
Save settings and update deploymentfor the change to take effect.
See Deploy templates and app environment for more information on changing app settings.
You can also specify the start command by creating a file in the Base Directory of your source code repo called
Procfile. The file should contain a line that starts with
web:, followed by your app's start command.
Example:web: ./myapp index.js --port=$PORT
This template includes a set of pre-flight checks that are performed before your app is deployed. These checks help ensure your app meets certain requirements and can identify some common issues before deployment.
»Check: main.go exists
The build pack used to build the app's container image checks to see if
main.go exists to detect that this is a Go app.
By default, the template looks for
main.go in the root of your GitHub repo.
If your app's
main.go is in a sub-directory of your repo, you need to set Base Directory to the directory that contains
main.go and your
If this check fails:
Confirm you are deploying the correct GitHub repo and correct branch which contains a
main.gofile for your Go app.
Confirm your app's
main.gofile is in the root directory of your GitHub repo or you have set Base Directory to the directory path within the repo where your
main.gofile is located.
»Check: Template settings validated
This checks that your Adaptable app's settings object matches the structure required by the template. Normally, Adaptable checks this each time you modify your app's settings and will not allow you to save invalid settings.
If this check fails:
- Contact Adaptable support with any error message you receive.
»Check: HTTP Listener on PORT
In order to run your app on the Adaptable Container Service, it must be an app that listens for HTTP requests.
More specifically, it must listen on IP address
0.0.0.0 on the TCP port specified by the
PORT environment variable.
See the Deploying a Go App Guide for instructions on how to set up your app to correctly listen for HTTP requests.
This check cannot be done automatically by analyzing your app's source code, so the first time your app is deployed on Adaptable, you'll be asked to click the checkbox that confirms that your app will listen on the port specified by
If you have a different kind of app that you'd like to deploy or if you need help getting your app set up correctly, we can help! Contact Adaptable's friendly support team for more information.
»Additional app requirements
»Containerized app requirements
In order to run your app on the Adaptable Container Service, it must meet a few requirements. Most web-based apps shouldn't have trouble meeting these requirements.
Your app must listen for HTTP requests on 0.0.0.0 on the TCP port specified by the
PORTenvironment variable. (Alternatively, your app can listen on a fixed port, but you will have to specify this PORT in your App's settings after the first failed deploy.)
Your app must be stateless. Although your app can write to local disk storage, that storage is a memory file system and will be lost when your app is scaled down or updated. Local disk storage is also not shared between multiple autoscaled instances of your app. This means your app cannot use local file-based databases, such as NeDB or SQLite.
Your app cannot perform background activities outside the scope of request handling. Your app's CPU allocation is set to zero when your app is not processing a network request.
You should not perform HTTPS/TLS in your app itself. Adaptable automatically provides HTTPS/TLS via our highly scalable load balancing tier.
When your app starts, it must listen for HTTP requests within 4 minutes of being started.