CF

AWS Serverless REST APIs for Java Developers. CI/CD included

14h 34m 16s
English
Paid

AWS Serverless REST APIs for Java Developers. CI/CD included is a 222-lesson 14 hours 34 minutes self-paced course by Udemy. AWS Serverless is probably the quickest way to build a very stable REST APIs that scale to serve millions of users.

Course facts

Lessons
222
Duration
14 hours 34 minutes
Level
All levels
Language
English
Updated
Instructor
Udemy
Price
Premium

AWS Serverless is probably the quickest way to build a very stable REST APIs that scale to serve millions of users. A very simple Mock API can be created and deployed in minutes. An API that uses AWS Lambda compute service will take longer but how much longer will depend on the business logic that you need to write. In this video course, you will learn what is REST API and how to create one using AWS Serverless Services.

You will learn in detail how to use Amazon API Gateway to create REST APIs, and AWS Lambda Compute Service to execute business logic. The course is designed for absolute beginners, so you do not need to have any experience with AWS Serverless.

By the end of this course, you will be able to:

  • Create RESTful API endpoints,

  • Build and deploy API with AWS SAM,

  • Validate HTTP request body and request parameters,

  • Transform HTTP request body into a different model,

  • Transform HTTP response JSON into a different one,

  • Deploy APIs into different stages,

  • Perform Canary Release Deployments and shift traffic between different versions of APIs,

  • Publish multiple versions of Lambda functions and shift traffic between these functions,

  • Document and Export REST API,

  • Implement User Sign-up with Amazon Cognito,

  • Learn to use Cognito Authorizer to control who can access your API in Amazon API Gateway,

  • Implement custom Lambda Authorizer that validates JWT,

  • Secure API endpoints with API Keys and learn to configure requests Throattling and Quota,

  • Unit Test AWS Lambda functions,

  • Build CI/CD Pipeline using AWS CodeCommit, AWS CodeBuild and AWS CodePipeline developer tools.

If you want to learn how to build REST APIs quickly, without starting, configuring, and managing any servers, then this course is for you.

Who teaches AWS Serverless REST APIs for Java Developers. CI/CD included? 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.

What lessons are included in AWS Serverless REST APIs for Java Developers. CI/CD included?

This is a demo lesson (10:00 remaining)

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

View Pricing
0:00
/
#1: Introduction
All Course Lessons (222)
#Lesson TitleDurationAccess
1
Introduction Demo
02:11
2
What is an API?
05:33
3
Introduction to REST API
04:07
4
REST API Resources & URIs
06:16
5
API Operations and HTTP methods
02:59
6
The multi-tier architecture and Microservices
06:57
7
AWS Serverless services overview
08:58
8
AWS Serverless architecture example
06:07
9
Introduction
05:43
10
Import from Swagger or Open API 3
08:21
11
Method execution flow overview
06:56
12
Method request overview
03:23
13
Integration request overview
02:56
14
Integration response overview
01:36
15
Method response overview
02:38
16
Trying how it works
03:02
17
Introduction
02:52
18
Creating a new API
02:06
19
Creating a new Resource
02:58
20
Creating HTTP Method
04:31
21
Returning Mock Data
04:00
22
Path parameter
03:52
23
Reading the path parameter
04:13
24
Query String Parameters
01:29
25
Reading Query String Parameter in a Mapping template
04:07
26
Deploying Mock API
04:56
27
Documenting API
07:05
28
Introduction
00:50
29
Export API and Test with Swagger
05:59
30
Export API with Gateway Extensions
03:43
31
Export API and Test with Postman
03:27
32
Validating Request Parameters & Headers
04:46
33
Validating Request Body - Creating a Model.
05:41
34
Associate Model with HTTP Request
01:39
35
Validating Request Body - Trying how it works.
02:00
36
Function as a Service(SaaS)
01:34
37
Lambda function & other Services
06:13
38
Anatomy of a Java Lambda function handler
02:16
39
Lambda Execution Environment
04:51
40
Cold start, warm start & provisioned concurrency
03:19
41
Pricing
03:39
42
Creating new Maven project
02:05
43
Adding Maven dependencies
02:24
44
Maven Shade Plugin
02:51
45
Creating Lambda function
03:01
46
Reading Request returning Response
04:32
47
Creating function in AWS Console
03:03
48
Deploying Lambda function
02:50
49
Testing Lambda function with Input Template
02:50
50
Create new API project
01:02
51
Assigning Lambda function to API Endpoint
05:59
52
Introduction
03:25
53
Creating a new IAM User
05:15
54
Installing AWS SAM
04:33
55
Installing AWS CLI
03:40
56
Configure AWS Credentials on your computer
02:19
57
Creating a new project with SAM
04:54
58
Refactor project to use a different name
04:26
59
Read User Details JSON and return HTTP Response
10:21
60
SAM template file overview
05:29
61
SAM template - Resources
07:23
62
SAM template - Outputs
07:13
63
The event.json file
02:32
64
Invoke Remote Lambda function from local computer
01:56
65
Debug Lambda function locally
03:37
66
Deploy Lambda function to AWS
06:43
67
Invoke public API Endpoint
02:30
68
Viewing logs
04:51
69
Delete AWS SAM application
03:13
70
Introduction
02:29
71
Java Map instead of APIGatewayProxy Event objects
03:17
72
Deploying application to AWS
01:37
73
Creating a new Request Model
02:32
74
Creating a new Response Model
01:21
75
Transforming HTTP Request Payload
08:35
76
Reading New Request Model
01:53
77
Trying how it works
04:53
78
Response Mapping Template
04:39
79
Configure Method Response
01:29
80
Trying how the Response Mapping
02:15
81
Reading with Query String Parameters & Headers
04:10
82
Introduction
04:10
83
Deploy project
01:58
84
Customize the Default API Gateway Error Response
10:34
85
Trying how it works
02:52
86
Proxy Integration. Causing a 500 Server Error.
03:05
87
Proxy Integration. Handle Exception and return custom JSON.
02:09
88
Trying how it works
02:55
89
Deploy and disable Proxy Integration
04:13
90
Response code & Lambda Error Regex for 500 status code
05:02
91
Mapping template for 500 status code
03:49
92
Lambda Error Regex for Different Error
04:47
93
Handle multiple exceptions
05:33
94
Introduction
02:09
95
Deploying new code
02:56
96
Publishing a new version
03:35
97
Assign new version to API endpoint
02:30
98
Publish version #2
03:18
99
Lambda Aliases - Introduction
02:19
100
Creating an Alias
03:16
101
Using Alias in API Gateway
02:10
102
Trying how the Lambda Alias works
03:43
103
Shift traffic between two lambda versions
03:47
104
Introduction
04:19
105
Create Canary
03:10
106
Deploy changes to Canary
02:14
107
Trying how it works
01:40
108
Promoting and Deleting Canary
02:09
109
Creating Environment Variables in AWS SAM
05:03
110
Reading Environment Variables
02:15
111
Trying how it works
03:42
112
Creating Lambda environment variables in AWS Web Console
01:13
113
Environment variables encryption options
01:41
114
Creating new encryption key
03:14
115
Encrypting environment variables with AWS KMS key
02:31
116
Decrypting Environment Variables
07:04
117
Trying how it works
01:55
118
Introduction
03:19
119
User pool - Name and Attributes step
04:38
120
User pool - Policies step
01:19
121
User pool - MFA and verifications step
01:48
122
User pool - Message customizations step
03:51
123
User pool - Tags and Devices steps
01:41
124
User pool - Creating an App Client
03:20
125
User pool - Final steps
01:55
126
Adding AWS SDK Cognito Dependencies
04:57
127
Create User - Reading Request Body
02:20
128
Creating CognitoUserService and CreateUser function
01:45
129
Working on Cognito SignUpRequest
06:35
130
Generating Secret Hash value
04:58
131
Creating and using the CognitoIdentityProviderClient
05:11
132
Calling the createUser() function
05:57
133
User Sign-up. Trying how it works.
05:42
134
Creating the Confirm User Lambda function
01:24
135
Implementing Confirm User Signup function
04:57
136
Calling the Confirm User method
06:06
137
Define Confirm User Signup function in AWS SAM template
02:51
138
Encrypting environment variables
07:52
139
Decrypting Environment Variables in Java code
04:23
140
Updating Encryption & Decryption KMS Key
01:58
141
Trying how it works
01:58
142
Creating LoginUserHandler
01:36
143
Define LoginUserHandle in AWS SAM template
01:52
144
Implementing User Login method in the service class
08:25
145
Calling User Login method
04:47
146
Trying how it works
02:47
147
Error message as jSON rather than plain text
08:16
148
Creating a User Group
06:03
149
Implementing AddUserToGroup() method
03:21
150
Calling the AddUserToGroup() method
05:56
151
Encrypting Environment Variable
03:53
152
Define AddUserToGroup function in AWS SAM template
07:47
153
Trying how the Add User To Group function works
05:21
154
Creating GetUserHandler Lambda function
02:23
155
Define GetUserHandler function in AWS SAM template
03:08
156
Secure API endpoint with Cognito Authorizer
03:06
157
Using ID token with Cognito Authorizer
04:33
158
Implementing Get User Details method
05:09
159
Calling the Get User method
03:33
160
Trying how it works
01:53
161
Validating required HTTP header
03:28
162
Import Open API definition into SAM template
10:23
163
Introduction
03:55
164
Starter project overview & source code
05:18
165
Creating Lambda Authorizer in API Gateway
04:42
166
Import Open-API configuration into AWS SAM template
02:49
167
Lambda authorizer Output
04:06
168
Generating Policy Document
09:23
169
Trying how it works
02:02
170
Adding JWT validation dependencies
02:28
171
Implement the JWT validation function
07:16
172
Validating the JWT
04:40
173
Trying how JWT validation works
03:05
174
Implementing the GetUserByUsername function
06:02
175
Add Policy to allow the AWS SAM template file
02:34
176
Calling getUserByUsername() from handleRequest() method
04:02
177
Trying how it works
02:33
178
Introduction
03:10
179
Create a new API Key
01:57
180
Create a Usage Plan
03:23
181
Secure API Endpoint with API Key
02:57
182
Trying how it works
02:17
183
Introduction
01:53
184
Testing Pyramid
02:47
185
F.I.R.S.T principle
03:37
186
Adding JUnit Test Dependencies
03:42
187
Running and failing a test case
04:39
188
Naming a Unit Test Method
03:17
189
Arrange, Act, Assert
04:00
190
Unit Test Lifecycle methods
03:22
191
Creating Mock Objects
04:52
192
Mocking APIGatewayProxyRequestEvent
03:19
193
Mocking Context object
03:24
194
Mocking CognitoUserService class
03:22
195
Invoke function under test
02:29
196
Assertions for the CreateUserHandler Unit Test
07:31
197
Centralize property names
03:26
198
Test if function returns error message if request body is empty
06:47
199
Test if function returns error message when AwsServiceException takes place
09:01
200
Introduction to AWS CodeCommit
03:09
201
Git Branches
03:22
202
Creating Local Git Repository
03:23
203
Git Ignore file
03:55
204
Commit files to main branch
02:38
205
Creating Remote Git Repository
01:26
206
Creating User Credentials
04:43
207
Push Initial Commit to a Remote Git Branch
03:46
208
Push New Updates to a Remote Git Branch
04:30
209
Creating a Pull Request
02:37
210
Approving and Merging Pull Request
03:11
211
Introduction
02:18
212
Creating a new S3 bucket
02:16
213
Creating a BuildSpec file
08:10
214
Commit BuildSpec file to main branch
01:53
215
Creating a new CodeBuild project
08:01
216
Fixing a Unit Test method
02:22
217
Running Code Build
02:53
218
Introduction
02:40
219
CloudFormation Role
06:29
220
Creating CodePipeline to Deploy AWS Lambda
07:48
221
Execute a Change Set
04:12
222
Making code change that triggers pipeline
03:06
Unlock unlimited learning

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

Learn more about subscription

What courses are similar to AWS Serverless REST APIs for Java Developers. CI/CD included?

More courses by Udemy

Frequently asked questions

What prerequisites should I have before taking this course?
Before enrolling in the course, you should have a basic understanding of Java programming and familiarity with general web development concepts. Knowledge of APIs and HTTP methods will be beneficial. The course is designed for developers looking to expand their skills to AWS Serverless architecture and REST API development.
What kind of projects or applications will I build during the course?
In this course, you will build a REST API using AWS Serverless services. You will create a new API project, define resources and HTTP methods, and integrate them with AWS Lambda functions. The course provides exercises such as deploying mock APIs, exporting APIs for testing with Swagger and Postman, and deploying Lambda functions.
Who is the target audience for this course?
The course is intended for Java developers who wish to learn about building scalable REST APIs using AWS Serverless technologies. It is suitable for those looking to enhance their skills in cloud computing and serverless architecture. This course will also benefit developers interested in implementing microservices and multi-tier architecture.
How does this course compare to other REST API courses?
This course specifically focuses on using AWS Serverless services to build REST APIs, providing an overview of AWS Serverless architecture and practical examples. It covers aspects such as Lambda execution environments, API Gateway integration, and the use of tools like Swagger and Postman for testing. This makes it distinct from other courses which might not emphasize serverless solutions or AWS-specific tools.
What specific AWS services and tools are covered in this course?
The course covers several AWS services and tools including AWS Lambda, API Gateway, AWS SAM (Serverless Application Model), and AWS CLI (Command Line Interface). It also teaches how to configure AWS credentials, create and deploy Lambda functions, and use Maven for dependency management in Java projects.
What is not covered in this course?
The course does not cover non-Java programming languages or provide an in-depth exploration of AWS services beyond their use in serverless REST API creation. Advanced topics such as AWS security best practices or managing complex enterprise-level AWS environments are also outside the course's scope.
How much time should I expect to dedicate to this course?
With 222 lessons, the course is quite comprehensive. While the exact runtime is not provided, prospective students should be prepared to dedicate a significant amount of time to go through the materials, engage with practical exercises, and complete projects. The time commitment will vary depending on the student's prior experience and familiarity with the topics.