Search for a command to run...
Hi! I'm a CS student at the University of Cambridge, and an aspiring backend developer. I have experience with Rust and C#, and am particularly interested in cloud computing and distributed systems.
No comments yet. Be the first to comment.
In this series of posts, I guide you through the process of creating and deploying your own URL shortener. By the end, you will have learnt the basics of Rust, Docker, Svelte, and Elastic Beanstalk.
In this series of posts, I aim to guide you through the process of creating and deploying a public API. Over the course of the series, you will learn how to use the following technologies: Rust with Rocket web framework - for handling API requests D...
In the last post, we worked on containerizing the backend of our application, so that we can deploy it with a single command. In this post, we will create a static front-end application with Svelte + Bulma, and then integrate it into our Rust code + ...
In the last post, we created some unit tests that will allow us to automatically test our application. In this post, we will cover the process of Dockerizing our application in preparation for deploying with AWS Elastic Beanstalk. What is Docker? Exp...
In the last post, we created a simple URL-shortener API and tested it manually with curl and a browser. In this post, we will use Rust's integrated unit-testing features to allow testing with a single command, and then automate testing with GitHub Ac...
In the first post of the series, I covered the reasons for choosing Rust and AWS, as well as the process for initialising a new Rust project. If you haven't followed the steps in that article, you can find it here. In this article, we will create a s...
In the last post, we created a static front-end application with Svelte + Bulma, and then integrated it into our Rust code + Dockerfile. In this final post, we will cover the process of actually deploying the app to AWS Elastic Beanstalk.
Elastic Beanstalk is a service provided by AWS which enables developers to focus purely on application code, without worrying about the infrastructure the code is being run on. Although we won't be exploring the full power of EB, it is capable of capacity provisioning, load balancing, scaling, and application health monitoring.
The first step in manually deploying your application is to create a zipped archive of your code to upload to EB. As an effort to stay cross-platform, we will do this using git archive (this has the added benefit of automatically ignoring anything in the gitignore).
git archive --format=zip HEAD -o ./target/repo.zip
This will place a zip of our repo into the target folder.
Now we have the zip file, you should following the following steps:
If you go back the environments page, you will see that an environment with the name "production" has been created. It should have the status "Pending" - you will now have to wait around ten minutes for your application to build and startup (EB uses the docker-compose.yml file to build the images from scratch on the underlying EC2 instance).
Once the environment health transitions to "Ready", you should be able to go to the provided URL (HTTP only, as setting up HTTPS is beyond the scope of this series).
Manually updating your application like this can be time-consuming, so I will now show you how to automatically deploy your code with GitHub Actions.
First, you will need to use the "IAM" service to create a user (so that the workflow can access your AWS account). The user should be called "url-shortener-deploy" and the credential type should be "Programmatic access".
We will be using the Beanstalk Deploy, which requires the AWSElasticBeanstalkWebTier and AWSElasticBeanstalkManagedUpdatesCustomerRolePolicy permissions. Make sure to attach these to the IAM role, and then create the user.
Once you have clicked Create user, you will be shown a table with the access credentials. You will only be shown these once - don't close the window just yet. In a new tab, open your repo on GitHub and add the following secrets (Settings > Secrets > New repository secret):
url-shortener-deploy user, and then close the credential view on the AWS console.Next, create a new workflow called deploy.yml (this should be in the same directory as test.yml). This action will use the secrets we set in the last step to deploy our code to AWS whenever code is pushed to production.
name: Deploy to AWS
on:
push:
branches:
- production
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- name: Checkout Latest Repo
uses: actions/checkout@master
with:
ref: "production"
- name: Generate Deployment Package
run: mkdir target && git archive --format=zip HEAD -o ./target/repo.zip
- name: Get timestamp
uses: gerred/actions/current-time@master
id: current-time
- name: Run string replace
uses: frabert/replace-string-action@master
id: format-time
with:
pattern: '[:\.]+'
string: "${{ steps.current-time.outputs.time }}"
replace-with: "-"
flags: "g"
- name: Deploy to EB
uses: einaregilsson/beanstalk-deploy@v18
with:
aws_access_key: ${{ secrets.AWS_ACCESS_KEY_ID }}
aws_secret_key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
application_name: url-shortener
environment_name: production
version_label: "url-shortener-${{ steps.format-time.outputs.replaced }}"
region: eu-west-2
deployment_package: target/repo.zip
Note: The string replacement step simply sets the code version to the current time.
Now that we have created the workflow, we need to push to the production branch. Normally we can do this via a PR on the GitHub web interface, but that only works after we have created and pushed the branch. To do this, use the following git commands:
git branch production
git push origin production
If all goes correctly, your workflow should take about 15 minutes to deploy your code to AWS.
Now that you have the barebones structure up and running, perhaps you could try adding the following features:
That's all for this series! If you have any issues, make sure to check out the part-6 tag of my repo.
If you enjoyed reading this, then consider dropping a like or following me:
I'm just starting out, so the support is greatly appreciated!
Disclaimer - I'm a (mostly) self-taught programmer, and I use my blog to share things that I've learnt on my journey to becoming a better developer. Because of this, I apologize in advance for any inaccuracies I might have made - criticism and corrections are welcome!