CF

Deploy Spring Boot Microservices on AWS ECS with Fargate

7h 1m 39s
English
Paid

This comprehensive course is designed for Java developers eager to expand their skill set by deploying Spring Boot Microservices on AWS using Elastic Container Service (ECS). By the end of this course, you'll competently deploy, auto scale, and load balance Spring Boot Microservices in Docker containers on AWS's serverless infrastructure. Every lecture is beginner-friendly, simplifying complex topics through concise, step-by-step video lessons.

Key Learning Outcomes

Upon completing the course, you will be able to:

Manage Spring Boot Microservices

  • Operate Spring Boot Microservices using various Spring Boot profiles such as dev and prod.

  • Build Docker images for your microservices.

  • Publish Docker images efficiently to platforms like Docker Hub and AWS ECR.

  • Scan for security vulnerabilities to ensure your Spring Boot Microservices are protected.

Deploy Microservices on AWS

  • Set up a cluster on AWS Fargate, leveraging its serverless infrastructure.

  • Execute multiple instances of Spring Boot Microservices behind an Amazon Application Load Balancer.

  • Implement Auto Scaling to adjust resources based on demand.

  • Create an SSL certificate to activate secure HTTPS communication.

  • Utilize Route 53 to enable HTTPS communications for a custom domain name.

Advanced AWS Integrations

  • Deploy scalable MySQL servers using Amazon RDS.

  • Implement Centralized Configuration and manage configuration properties using Amazon Parameter Store.

  • Encrypt sensitive configuration properties and maintain them securely on AWS.

  • Facilitate microservice communication and discovery using Service Connect & Service Discovery.

Automate Development Processes

  • Apply best practices in Continuous Integration and Continuous Deployment (CI/CD).

  • Utilize Amazon Developer Tools such as CodeCommit, CodeBuild, and CodePipeline to streamline new code releases.

About the Author: Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 86 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 86 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction
All Course Lessons (86)
#Lesson TitleDurationAccess
1
Introduction Demo
04:30
2
Introduction to ECS
07:01
3
Microservices Architecture on AWS
05:47
4
What is ECS Cluster, Service, and Task?
03:03
5
AWS Account & Pricing
07:48
6
Run Users Microservice with Spring Tools Suite
05:34
7
Run Users Microservice using command-line
02:31
8
Run Albums Microservice with Spring Tools Suite
02:59
9
Download Postman HTTP Client
03:26
10
Microservices demo
11:40
11
Introduction
02:36
12
A Docker File
07:26
13
Docker Hub vs Amazon ECR (Elastic Container Registry)
04:04
14
Where to find Docker
02:22
15
Creating a Repository in Docker Hub
03:13
16
Building Docker Image for Docker Hub
03:04
17
Pushing Docker Image to Docker Hub
02:33
18
Create a repository in Amazon ECR
04:40
19
Scan Image for Security Vulnerabilities
02:13
20
Install or Update AWS CLI
03:46
21
Access Credentials for AWS CLI
04:05
22
Configure AWS CLI
05:04
23
Push Docker Image to Amazon ECR
03:33
24
View Image. Run Manual Scan. View Scan Results.
03:59
25
The New ECS Experience
02:07
26
Creating a new AWS Fargate Cluster
08:08
27
Configure task definition and containers
07:22
28
Configure environment, storage, monitoring, and tags
06:40
29
Creating a New ECS Service
09:06
30
Overview of an Active ECS Service
05:04
31
Configure a Security Group
03:38
32
Trying how Microservice works
04:22
33
Stopping a task
04:36
34
Introduction
06:44
35
Enable load balancer
07:39
36
Load Balancer Security Group
05:30
37
Trying how load balancer works
09:00
38
Point Custom Domain name to a Load Balancer
04:48
39
Trying how custom domain name works
03:14
40
Introduction
03:24
41
Request a TLS/SSL certificate from Amazon
02:12
42
Validate Domain Name Ownership
01:28
43
Create HTTPs Listener
03:08
44
Configure Security Group to allow port 443
02:37
45
Redirect HTTP traffic to HTTPs
01:58
46
Trying how it works
02:02
47
ECS Auto Scaling - Introduction
03:21
48
Configure Auto Scaling
07:42
49
Trying how it works
10:58
50
AWS RDS - Create MySQL Database
08:46
51
Creating a new ECS Task Definition
09:45
52
Deploy the New Task Definition
02:03
53
Configure Database Instance Security Group
03:28
54
Trying how it works
06:16
55
Introduction
02:39
56
Creating First Configuration Parameter
04:59
57
Encrypting Sensitive Configuration Properties
04:09
58
Creating the rest of the parameters
02:14
59
Updating Task Definition
07:41
60
Configure Execution Role
02:13
61
Trying how it works
03:01
62
Introduction
04:11
63
Service Discovery with Application Load Balancer
03:39
64
Service Connect - Introduction
01:39
65
Service Connect - Behind the Scenes
06:24
66
Enable Service Connect
05:57
67
Service Connect overview
03:41
68
Configure Users Service to user local DNS of Albums Microservice
05:52
69
Trying if Service Connect Discovery URL Works
06:41
70
Push Albums Microservice to AWS ECR
04:43
71
Create RDS MySQL Database for Albums Microservice
04:48
72
Define configuration parameters for Albums Microservices in the Parameter Store
06:55
73
Creating Task Definition for Albums Microservice
08:00
74
Creating ECS Service for Albums Microservice
08:11
75
Configure Security Group for Albums Microservice
02:47
76
Configure Security Group for Albums RDS
02:16
77
Introduction
06:56
78
Create CodeCommit repository for users microservice
01:59
79
Grant Permissions to work with AWS CodeCommit
02:56
80
Generate Git Credentials
01:23
81
Push code to AWS Code Commit repository
07:35
82
Creating Build Project
10:53
83
Buildspec.yml file overview
04:26
84
Grant ECR Permission
02:37
85
Creating Code Pipeline
08:11
86
Making code change that triggers Pipeline
08:00
Unlock unlimited learning

Get instant access to all 85 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for enrolling in this course?
This course is designed for Java developers. A foundational understanding of Java and experience with Spring Boot is recommended. Familiarity with basic command-line operations and some knowledge of Docker would be beneficial, as the course includes building Docker images and publishing them to platforms like Docker Hub and AWS ECR.
What types of projects will I work on during this course?
Throughout the course, you will work on deploying Spring Boot Microservices. You will build and deploy Docker containers for these microservices, set up an AWS Fargate cluster, and use an Amazon Application Load Balancer for handling multiple instances. Additionally, you will implement security measures such as SSL certificates and use Route 53 for custom domain names.
Who is the target audience for this course?
The course is aimed at Java developers who want to enhance their skills in deploying Spring Boot Microservices on AWS. It is suitable for those looking to understand serverless infrastructure, auto scaling, and load balancing within the AWS ecosystem. Beginners to AWS and Docker can also benefit from the step-by-step lessons.
How does the depth of this course compare to similar courses?
This course offers a comprehensive approach to deploying microservices on AWS using ECS and Fargate, covering topics like Docker image management, security scanning, and SSL configuration. It provides in-depth tutorials on AWS services such as RDS for database management and Parameter Store for configuration management, which might not be as extensively covered in shorter or more general courses.
What specific AWS tools and platforms does the course cover?
The course covers several AWS tools and platforms, including AWS Elastic Container Service (ECS), AWS Fargate for serverless container management, Amazon RDS for deploying MySQL databases, and Route 53 for domain name management. It also includes using AWS CLI for command-line operations and Amazon ECR for Docker image storage.
What topics are not covered in this course?
The course does not cover the basics of Java or Spring Boot development in detail, as it assumes that learners have prior experience in these areas. It also does not delve into other AWS services not directly related to ECS, Fargate, or microservices, such as AWS Lambda or AWS S3.
What is the time commitment required to complete the course?
The course consists of 86 lessons designed to be beginner-friendly and concise, although the total runtime is not specified. It is structured to allow learners to progress at their own pace, with a focus on practical, hands-on exercises that align with each lesson's objectives. This flexibility enables students to fit the course around their schedules.