# Deploying Go applications with Elastic Beanstalk
This chapter provides instructions for configuring and deploying your Go web application to AWS Elastic Beanstalk. Elastic Beanstalk makes it easy to deploy, manage, and scale your Go web applications using Amazon Web Services.
You can deploy your application in just a few minutes using the Elastic Beanstalk Command Line Interface (EB CLI) or by using the Elastic Beanstalk console. After you deploy your Elastic Beanstalk application, you can continue to use the EB CLI to manage your application and environment, or you can use the Elastic Beanstalk console, AWS CLI, or the APIs.
Follow the [QuickStart for Go](go-quickstart.md) for step-by-step instructions to create and deploy a *Hello World* Go web application with the EB CLI.
**Topics**
+ [QuickStart: Deploy a Go application to Elastic Beanstalk](go-quickstart.md)
+ [Setting up your Go development environment for Elastic Beanstalk](go-devenv.md)
+ [Using the Elastic Beanstalk Go platform](go-environment.md)
# QuickStart: Deploy a Go application to Elastic Beanstalk
This QuickStart tutorial walks you through the process of creating a Go application and deploying it to an AWS Elastic Beanstalk environment.
**Not for production use**
Examples are intended for demonstration only. Do not use example applications in production.
**Topics**
+ [Your AWS account](#go-quickstart-aws-account)
+ [Prerequisites](#go-quickstart-prereq)
+ [Step 1: Create a Go application](#go-quickstart-create-app)
+ [Step 2: Deploy your Go application with the EB CLI](#go-quickstart-deploy)
+ [Step 3: Run your application on Elastic Beanstalk](#go-quickstart-run-eb-ap)
+ [Step 4: Clean up](#go-tutorial-cleanup)
+ [AWS resources for your application](#go-quickstart-eb-resources)
+ [Next steps](#go-quickstart-next-steps)
+ [Deploy with the Elastic Beanstalk console](#go-quickstart-console)
## Your AWS account
If you're not already an AWS customer, you need to create an AWS account. Signing up enables you to access Elastic Beanstalk and other AWS services that you need.
If you already have an AWS account, you can move on to [Prerequisites](#go-quickstart-prereq).
### Create an AWS account
#### Sign up for an AWS account
If you do not have an AWS account, complete the following steps to create one.
**To sign up for an AWS account**
1. Open [https://portal.aws.amazon.com/billing/signup](https://portal.aws.amazon.com/billing/signup).
1. Follow the online instructions.
Part of the sign-up procedure involves receiving a phone call or text message and entering a verification code on the phone keypad.
When you sign up for an AWS account, an *AWS account root user* is created. The root user has access to all AWS services and resources in the account. As a security best practice, assign administrative access to a user, and use only the root user to perform [tasks that require root user access](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS sends you a confirmation email after the sign-up process is complete. At any time, you can view your current account activity and manage your account by going to [https://aws.amazon.com/](https://aws.amazon.com/) and choosing **My Account**.
#### Create a user with administrative access
After you sign up for an AWS account, secure your AWS account root user, enable AWS IAM Identity Center, and create an administrative user so that you don't use the root user for everyday tasks.
**Secure your AWS account root user**
1. Sign in to the [AWS Management Console](https://console.aws.amazon.com/) as the account owner by choosing **Root user** and entering your AWS account email address. On the next page, enter your password.
For help signing in by using root user, see [Signing in as the root user](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) in the *AWS Sign-In User Guide*.
1. Turn on multi-factor authentication (MFA) for your root user.
For instructions, see [Enable a virtual MFA device for your AWS account root user (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) in the *IAM User Guide*.
**Create a user with administrative access**
1. Enable IAM Identity Center.
For instructions, see [Enabling AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) in the *AWS IAM Identity Center User Guide*.
1. In IAM Identity Center, grant administrative access to a user.
For a tutorial about using the IAM Identity Center directory as your identity source, see [ Configure user access with the default IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) in the *AWS IAM Identity Center User Guide*.
**Sign in as the user with administrative access**
+ To sign in with your IAM Identity Center user, use the sign-in URL that was sent to your email address when you created the IAM Identity Center user.
For help signing in using an IAM Identity Center user, see [Signing in to the AWS access portal](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) in the *AWS Sign-In User Guide*.
**Assign access to additional users**
1. In IAM Identity Center, create a permission set that follows the best practice of applying least-privilege permissions.
For instructions, see [ Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) in the *AWS IAM Identity Center User Guide*.
1. Assign users to a group, and then assign single sign-on access to the group.
For instructions, see [ Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) in the *AWS IAM Identity Center User Guide*.
## Prerequisites
To follow the procedures in this guide, you will need a command line terminal or shell to run commands. Commands are shown in listings preceded by a prompt symbol (\$1) and the name of the current directory, when appropriate.
```
~/eb-project$ this is a command
this is output
```
On Linux and macOS, you can use your preferred shell and package manager. On Windows you can [install the Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/install-win10) to get a Windows-integrated version of Ubuntu and Bash.
### EB CLI
This tutorial uses the Elastic Beanstalk Command Line Interface (EB CLI). For details on installing and configuring the EB CLI, see [Install EB CLI with setup script (recommended)](eb-cli3.md#eb-cli3-install) and [Configure the EB CLI](eb-cli3-configuration.md).
## Step 1: Create a Go application
Create a project directory.
```
~$ mkdir eb-go
~$ cd eb-go
```
Next, create an application that you'll deploy using Elastic Beanstalk. We'll create a "Hello World" RESTful web service.
This example prints a customized greeting that varies based on the path used to access the service.
Create a text file in this directory named `application.go` with the following contents.
**Example `~/eb-go/application.go`**
```
package main
import (
"fmt"
"net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/" {
fmt.Fprintf(w, "Hello World! Append a name to the URL to say hello. For example, use %s/Mary to say hello to Mary.", r.Host)
} else {
fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
}
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":5000", nil)
}
```
## Step 2: Deploy your Go application with the EB CLI
Next, you create your application environment and deploy your configured application with Elastic Beanstalk.
**To create an environment and deploy your Go application**
1. Initialize your EB CLI repository with the **eb init** command.
```
~/eb-go$ eb init -p go go-tutorial --region us-east-2
Application go-tutorial has been created.
```
This command creates an application named `go-tutorial` and configures your local repository to create environments with the latest Go platform version.
1. (Optional) Run **eb init** again to configure a default key pair so that you can use SSH to connect to the EC2 instance running your application.
```
~/eb-go$ eb init
Do you want to set up SSH for your instances?
(y/n): y
Select a keypair.
1) my-keypair
2) [ Create new KeyPair ]
```
Select a key pair if you have one already, or follow the prompts to create one. If you don't see the prompt or need to change your settings later, run **eb init -i**.
1. Create an environment and deploy your application to it with **eb create**. Elastic Beanstalk automatically builds a zip file for your application and starts it on port 5000.
```
~/eb-go$ eb create go-env
```
It takes about five minutes for Elastic Beanstalk to create your environment.
## Step 3: Run your application on Elastic Beanstalk
When the process to create your environment completes, open your website with **eb open**.
```
~/eb-go$ eb open
```
Congratulations\$1 You've deployed a Go application with Elastic Beanstalk\$1 This opens a browser window using the domain name created for your application.
## Step 4: Clean up
You can terminate your environment when you finish working with your application. Elastic Beanstalk terminates all AWS resources associated with your environment.
To terminate your Elastic Beanstalk environment with the EB CLI run the following command.
```
~/eb-go$ eb terminate
```
## AWS resources for your application
You just created a single instance application. It serves as a straightforward sample application with a single EC2 instance, so it doesn't require load balancing or auto scaling. For single instance applications Elastic Beanstalk creates the following AWS resources:
+ **EC2 instance** – An Amazon EC2 virtual machine configured to run web apps on the platform you choose.
Each platform runs a different set of software, configuration files, and scripts to support a specific language version, framework, web container, or combination thereof. Most platforms use either Apache or nginx as a reverse proxy that processes web traffic in front of your web app, forwards requests to it, serves static assets, and generates access and error logs.
+ **Instance security group** – An Amazon EC2 security group configured to allow incoming traffic on port 80. This resource lets HTTP traffic from the load balancer reach the EC2 instance running your web app. By default, traffic is not allowed on other ports.
+ **Amazon S3 bucket** – A storage location for your source code, logs, and other artifacts that are created when you use Elastic Beanstalk.
+ **Amazon CloudWatch alarms** – Two CloudWatch alarms that monitor the load on the instances in your environment and are triggered if the load is too high or too low. When an alarm is triggered, your Auto Scaling group scales up or down in response.
+ **CloudFormation stack** – Elastic Beanstalk uses CloudFormation to launch the resources in your environment and propagate configuration changes. The resources are defined in a template that you can view in the [CloudFormation console](https://console.aws.amazon.com/cloudformation).
+ **Domain name** – A domain name that routes to your web app in the form **subdomain*.*region*.elasticbeanstalk.com*.
Elastic Beanstalk manages all of these resources. When you terminate your environment, Elastic Beanstalk terminates all the resources that it contains.
## Next steps
After you have an environment running an application, you can deploy a new version of the application or a different application at any time. Deploying a new application version is very quick because it doesn't require provisioning or restarting EC2 instances. You can also explore your new environment using the Elastic Beanstalk console. For detailed steps, see [Explore your environment](GettingStarted.md#GettingStarted.Explore) in the *Getting started* chapter of this guide.
After you deploy a sample application or two and are ready to start developing and running Go applications locally, see [Setting up your Go development environment for Elastic Beanstalk](go-devenv.md).
## Deploy with the Elastic Beanstalk console
You can also use the Elastic Beanstalk console to launch the sample application. For detailed steps, see [Create an example application](GettingStarted.md#GettingStarted.CreateApp) in the *Getting started* chapter of this guide.
# Setting up your Go development environment for Elastic Beanstalk
This topic provides instructions to set up a Go development environment to test your application locally prior to deploying it to AWS Elastic Beanstalk. It also references websites that provide installation instructions for useful tools.
## Installing Go
To run Go applications locally, install Go. If you don't need a specific version, get the latest version that Elastic Beanstalk supports. For a list of supported versions, see [Go](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.go) in the *AWS Elastic Beanstalk Platforms* document.
Download Go at [https://golang.org/doc/install](https://golang.org/doc/install).
## Installing the AWS SDK for Go
If you need to manage AWS resources from within your application, install the AWS SDK for Go by using the following command.
```
$ go get github.com/aws/aws-sdk-go
```
For more information, see [AWS SDK for Go](https://aws.amazon.com/sdk-for-go/).
# Using the Elastic Beanstalk Go platform
This topic describes how to configure, build, and run your Go applications on Elastic Beanstalk.
AWS Elastic Beanstalk supports a number of platform branches for different versions of the Go programming language. See [Go](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.go) in the *AWS Elastic Beanstalk Platforms* document for a full list.
For simple Go applications, there are two ways to deploy your application:
+ Provide a source bundle with a source file at the root called `application.go` that contains the main package for your application. Elastic Beanstalk builds the binary using the following command:
```
go build -o bin/application application.go
```
After the application is built, Elastic Beanstalk starts it on port 5000.
+ Provide a source bundle with a binary file called `application`. The binary file can be located either at the root of the source bundle or in the `bin/` directory of the source bundle. If you place the `application` binary file in both locations, Elastic Beanstalk uses the file in the `bin/` directory.
Elastic Beanstalk launches this application on port 5000.
In both cases, with our supported Go platform branches, you can also provide module requirements in a file called `go.mod`. For more information, see [Migrating to Go Modules](https://blog.golang.org/migrating-to-go-modules) in the Go blog.
For more complex Go applications, there are two ways to deploy your application:
+ Provide a source bundle that includes your application source files, along with a [Buildfile](go-buildfile.md) and a [Procfile](go-procfile.md). The Buildfile includes a command to build the application, and the Procfile includes instructions to run the application.
+ Provide a source bundle that includes your application binary files, along with a Procfile. The Procfile includes instructions to run the application.
The Go platform includes a proxy server to serve static assets and forward traffic to your application. You can [extend or override the default proxy configuration](go-nginx.md) for advanced scenarios.
For details about the various ways you can extend an Elastic Beanstalk Linux-based platform, see [Extending Elastic Beanstalk Linux platforms](platforms-linux-extend.md).
## Configuring your Go environment
The Go platform settings let you fine-tune the behavior of your Amazon EC2 instances. You can edit the Elastic Beanstalk environment's Amazon EC2 instance configuration using the Elastic Beanstalk console.
Use the Elastic Beanstalk console to enable log rotation to Amazon S3 and configure variables that your application can read from the environment.
**To configure your Go environment in the Elastic Beanstalk console**
1. Open the [Elastic Beanstalk console](https://console.aws.amazon.com/elasticbeanstalk), and in the **Regions** list, select your AWS Region.
1. In the navigation pane, choose **Environments**, and then choose the name of your environment from the list.
1. In the navigation pane, choose **Configuration**.
1. In the **Updates, monitoring, and logging** configuration category, choose **Edit**.
### Log options
The Log Options section has two settings:
+ **Instance profile** – Specifies the instance profile that has permission to access the Amazon S3 bucket associated with your application.
+ **Enable log file rotation to Amazon S3** – Specifies whether log files for your application's Amazon EC2 instances are copied to the Amazon S3 bucket associated with your application.
### Static files
To improve performance, you can use the **Static files** section to configure the proxy server to serve static files (for example, HTML or images) from a set of directories inside your web application. For each directory, you set the virtual path to directory mapping. When the proxy server receives a request for a file under the specified path, it serves the file directly instead of routing the request to your application.
For details about configuring static files using configuration files or the Elastic Beanstalk console, see [Serving static files](environment-cfg-staticfiles.md).
### Environment properties
The **Environment Properties** section lets you specify environment configuration settings on the Amazon EC2 instances that are running your application. Environment properties are passed in as key-value pairs to the application.
Inside the Go environment running in Elastic Beanstalk, environment variables are accessible using the `os.Getenv` function. For example, you could read a property named `API_ENDPOINT` to a variable with the following code:
```
endpoint := os.Getenv("API_ENDPOINT")
```
See [Environment variables and other software settings](environments-cfg-softwaresettings.md) for more information.
## Go configuration namespace
You can use a [configuration file](ebextensions.md) to set configuration options and perform other instance configuration tasks during deployments. Configuration options can be [platform specific](command-options-specific.md) or apply to [all platforms](command-options-general.md) in the Elastic Beanstalk service as a whole. Configuration options are organized into *namespaces*.
The Go platform doesn't define any platform-specific namespaces. You can configure the proxy to serve static files by using the `aws:elasticbeanstalk:environment:proxy:staticfiles` namespace. For details and an example, see [Serving static files](environment-cfg-staticfiles.md).
Elastic Beanstalk provides many configuration options for customizing your environment. In addition to configuration files, you can also set configuration options using the console, saved configurations, the EB CLI, or the AWS CLI. See [Configuration options](command-options.md) for more information.
## The Amazon Linux AMI (preceding Amazon Linux 2) Go platform
If your Elastic Beanstalk Go environment uses an Amazon Linux AMI platform version (preceding Amazon Linux 2), read the additional information in this section.
**Notes**
The information in this topic only applies to platform branches based on Amazon Linux AMI (AL1). AL2023/AL2 platform branches are incompatible with previous Amazon Linux AMI (AL1) platform versions and *require different configuration settings*.
On [July 18, 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html), Elastic Beanstalk set the status of all platform branches based on Amazon Linux AMI (AL1) to **retired**. For more information about migrating to a current and fully supported Amazon Linux 2023 platform branch, see [Migrating your Elastic Beanstalk Linux application to Amazon Linux 2023 or Amazon Linux 2](using-features.migration-al.md).
### Go configuration namespaces — Amazon Linux AMI (AL1)
You can use a [configuration file](ebextensions.md) to set configuration options and perform other instance configuration tasks during deployments. Configuration options can be [platform specific](command-options-specific.md) or apply to [all platforms](command-options-general.md) in the Elastic Beanstalk service as a whole. Configuration options are organized into *namespaces*.
**Note**
The information in this topic only applies to platform branches based on Amazon Linux AMI (AL1). AL2023/AL2 platform branches are incompatible with previous Amazon Linux AMI (AL1) platform versions and *require different configuration settings*.
The Amazon Linux AMI Go platform supports one platform-specific configuration namespace in addition to the [namespaces supported by all platforms](command-options-general.md). The `aws:elasticbeanstalk:container:golang:staticfiles` namespace lets you define options that map paths on your web application to folders in your application source bundle that contain static content.
For example, this [configuration file](ebextensions.md) tells the proxy server to serve files in the `staticimages` folder at the path `/images`:
**Example .ebextensions/go-settings.config**
```
option_settings:
aws:elasticbeanstalk:container:golang:staticfiles:
/html: statichtml
/images: staticimages
```
Elastic Beanstalk provides many configuration options for customizing your environment. In addition to configuration files, you can also set configuration options using the console, saved configurations, the EB CLI, or the AWS CLI. See [Configuration options](command-options.md) for more information.
# Configuring custom start commands with a Procfile on Elastic Beanstalk
To specify custom commands to start a Go application, include a file called `Procfile` at the root of your source bundle.
For details about writing and using a `Procfile`, see [Buildfile and Procfile](platforms-linux-extend.build-proc.md).
**Example Procfile**
```
web: bin/server
queue_process: bin/queue_processor
foo: bin/fooapp
```
You must call the main application `web`, and list it as the first command in your `Procfile`. Elastic Beanstalk exposes the main `web` application on the root URL of the environment; for example, `http://my-go-env.elasticbeanstalk.com`.
Elastic Beanstalk also runs any application whose name does not have the `web_` prefix, but these applications are not available from outside of your instance.
Elastic Beanstalk expects processes run from the `Procfile` to run continuously. Elastic Beanstalk monitors these applications and restarts any process that terminates. For short-running processes, use a [Buildfile](go-buildfile.md) command.
## Using a Procfile on Amazon Linux AMI (preceding Amazon Linux 2)
If your Elastic Beanstalk Go environment uses an Amazon Linux AMI platform version (preceding Amazon Linux 2), read the additional information in this section.
**Notes**
The information in this topic only applies to platform branches based on Amazon Linux AMI (AL1). AL2023/AL2 platform branches are incompatible with previous Amazon Linux AMI (AL1) platform versions and *require different configuration settings*.
On [July 18, 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html), Elastic Beanstalk set the status of all platform branches based on Amazon Linux AMI (AL1) to **retired**. For more information about migrating to a current and fully supported Amazon Linux 2023 platform branch, see [Migrating your Elastic Beanstalk Linux application to Amazon Linux 2023 or Amazon Linux 2](using-features.migration-al.md).
### Port passing — Amazon Linux AMI (AL1)
**Note**
The information in this topic only applies to platform branches based on Amazon Linux AMI (AL1). AL2023/AL2 platform branches are incompatible with previous Amazon Linux AMI (AL1) platform versions and *require different configuration settings*.
Elastic Beanstalk configures the nginx proxy to forward requests to your application on the port number specified in the `PORT` [environment property](go-environment.md#go-options) for your application. Your application should always listen on that port. You can access this variable within your application by calling the `os.Getenv("PORT")` method.
Elastic Beanstalk uses the port number specified in the `PORT` environment property for the port for the first application in the `Procfile`, and then increments the port number for each subsequent application in the `Procfile` by 100. If the `PORT` environment property is not set, Elastic Beanstalk uses 5000 for the initial port.
In the preceding example, the `PORT` environment property for the `web` application is 5000, the `queue_process` application is 5100, and the `foo` application is 5200.
You can specify the initial port by setting the `PORT` option with the [aws:elasticbeanstalk:application:environment](command-options-general.md#command-options-general-elasticbeanstalkapplicationenvironment) namespace, as shown in the following example.
```
option_settings:
- namespace: aws:elasticbeanstalk:application:environment
option_name: PORT
value:
```
For more information about setting environment properties for your application, see [Option settings](ebextensions-optionsettings.md).
# Custom build and configuration with a Buildfile on Elastic Beanstalk
To specify a custom build and configuration command for your Go application, include a file called `Buildfile` at the root of your source bundle. The file name is case sensitive. Use the following format for the `Buildfile`:
```
:
```
The command in your `Buildfile` must match the following regular expression: `^[A-Za-z0-9_]+:\s*.+$`.
Elastic Beanstalk doesn't monitor the application that is run with a `Buildfile`. Use a `Buildfile` for commands that run for short periods and terminate after completing their tasks. For long-running application processes that should not exit, use the [Procfile](go-procfile.md) instead.
In the following example of a `Buildfile`, `build.sh` is a shell script that is located at the root of the source bundle:
```
make: ./build.sh
```
All paths in the `Buildfile` are relative to the root of the source bundle. If you know in advance where the files reside on the instance, you can include absolute paths in the `Buildfile`.
# Configuring the proxy server
Elastic Beanstalk uses nginx as the reverse proxy to map your application to your Elastic Load Balancing load balancer on port 80. Elastic Beanstalk provides a default nginx configuration that you can either extend or override completely with your own configuration.
By default, Elastic Beanstalk configures the nginx proxy to forward requests to your application on port 5000. You can override the default port by setting the `PORT` [environment property](go-environment.md#go-options) to the port on which your main application listens.
**Note**
The port that your application listens on doesn't affect the port that the nginx server listens to receive requests from the load balancer.
**Configuring the proxy server on your platform version**
All AL2023/AL2 platforms support a uniform proxy configuration feature. For more information about configuring the proxy server on your platform versions running AL2023/AL2, see [Reverse proxy configuration](platforms-linux-extend.proxy.md).
## Configuring the proxy on Amazon Linux AMI (preceding Amazon Linux 2)
**Notes**
The information in this topic only applies to platform branches based on Amazon Linux AMI (AL1). AL2023/AL2 platform branches are incompatible with previous Amazon Linux AMI (AL1) platform versions and *require different configuration settings*.
On [July 18, 2022](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html), Elastic Beanstalk set the status of all platform branches based on Amazon Linux AMI (AL1) to **retired**. For more information about migrating to a current and fully supported Amazon Linux 2023 platform branch, see [Migrating your Elastic Beanstalk Linux application to Amazon Linux 2023 or Amazon Linux 2](using-features.migration-al.md).
If your Elastic Beanstalk Go environment uses an Amazon Linux AMI platform version (preceding Amazon Linux 2), read the information in this section.
### Extending and overriding the default proxy configuration — Amazon Linux AMI (AL1)
Elastic Beanstalk uses nginx as the reverse proxy to map your application to your load balancer on port 80. If you want to provide your own nginx configuration, you can override the default configuration provided by Elastic Beanstalk by including the `.ebextensions/nginx/nginx.conf` file in your source bundle. If this file is present, Elastic Beanstalk uses it in place of the default nginx configuration file.
If you want to include directives in addition to those in the `nginx.conf` `http` block, you can also provide additional configuration files in the `.ebextensions/nginx/conf.d/` directory of your source bundle. All files in this directory must have the `.conf` extension.
To take advantage of functionality provided by Elastic Beanstalk, such as [Enhanced health reporting and monitoring in Elastic Beanstalk](health-enhanced.md), automatic application mappings, and static files, you must include the following line in the `server` block of your nginx configuration file:
```
include conf.d/elasticbeanstalk/*.conf;
```