Made withGinClip

Golang Gin Framework Crash Course 05 | Deployment on AWS with Elastic Beanstalk (bonus: IAM setup)

P

Pragmatic Reviews

Creator on the Gin channel

Watch on YouTube ↗

15K viewsMar 1, 202013:38 runtime

Learn to deploy a Golang Gin framework application on Amazon Web Services using AWS Elastic Beanstalk. This guide covers the full deployment workflow, starting with creating a custom IAM policy for secure access and configuring the Go application environment. Understand how…

Chapters

#gin#clip#backend

AWS Elastic Beanstalk Overview

AWS Elastic Beanstalk is a Platform as a Service (PaaS) for deploying and scaling web applications. It abstracts away underlying infrastructure management.

Managed Services: EC2, S3, CloudFormation, Load Balancers, Auto Scaling Groups, Elastic IPs.
Supported Runtimes: Go, Node.js, Java, .NET, Python, Ruby, PHP, and Docker.
Application Types:
- Web Server: Standard request-response applications.
- Worker: Processes background jobs from an SQS queue.

IAM Configuration for Deployment

Important
Follow the Principle of Least Privilege. Avoid using the default ElasticBeanstalkFullAccess policy and create a custom policy tailored to your needs.

Steps to Create a Secure IAM Policy:

Go to IAM -> Policies in the AWS Console.
Find ElasticBeanstalkFullAccess and copy its JSON content.
Click Create policy, paste the JSON, and remove permissions for services you won't use (e.g., RDS, DynamoDB, SQS).
Name and create the new policy (e.g., eb-deploy-policy).
Create a new User Group (e.g., eb-deployers).
Attach your custom policy to the new group.
Add your IAM user to this group.

Go Application Preparation

Port Configuration

Your Go application needs to listen on the correct port.

By default, Elastic Beanstalk's Nginx proxy forwards incoming traffic to port 5000 on the EC2 instance.
It's best practice to read the port from an environment variable, with 5000 as the fallback.

port := os.Getenv("PORT")
if port == "" {
    port = "5000"
}
router.Run(":" + port)

Platform-Specific Deployment Files

For a non-Docker Go deployment, you must provide these files at the project root:

build.sh (or similar script): A shell script to build the application. It typically downloads dependencies and runs go build.
```
# scripts/build.sh
go get -d -v ./...
go build -o bin/application -v
```
Buildfile: A text file that tells Elastic Beanstalk which command to run to build your application. It should point to your build script.
```
build: ./scripts/build.sh
```
Procfile: A text file that specifies the command to run your compiled application.
```
web: bin/application
```

Deployment with the EB CLI

Tip
Use a tool like cloudping.info to choose an AWS region with the lowest latency for you.

eb init: Initializes the application repository. You'll be prompted to select a region, an application name, and the platform (Go).
- This creates a .elasticbeanstalk/config.yml file with your settings.
eb create [environment-name]: Creates a new environment and deploys your code.
- This command zips your application, uploads it to S3, and provisions all necessary resources (EC2, Security Group, etc.).
- It will output a public DNS name you can use to access your application.

Managing the Deployed Environment

Use the Elastic Beanstalk Console to manage your running application:

Configuration: View and edit environment variables, change instance capacity (single vs. load-balanced), and configure auto-scaling triggers.
Logs: Request and download application and web server logs from the EC2 instances.
Health: Get an at-a-glance overview of the environment's status and recent events.
Monitoring: View performance metrics like CPU utilization, network I/O, and latency.