AWS Elastic Beanstalk Platform as a Service – SAP-C02 Study Guide

Purpose of This Lesson

AWS Elastic Beanstalk is a Platform as a Service (PaaS) offering that simplifies application deployment. It provisions and manages the AWS infrastructure required to run an application while allowing developers to focus primarily on application code.

This lesson focuses on how Elastic Beanstalk differs from Infrastructure as a Service (IaaS), how its application and environment model works, and when to use web server or worker environments.

Key Concepts

IaaS versus PaaS

With an IaaS service such as Amazon EC2, AWS manages the underlying facilities, physical hardware, and virtualization layer. The customer remains responsible for the operating system and everything above it, including:

• Operating system configuration and patching
• Security hardening
• Runtime and framework installation
• Application deployment and updates
• Capacity, scaling, and much of the operational configuration

Elastic Beanstalk provides a higher-level deployment model. You upload application source code, and Elastic Beanstalk provisions and manages the supporting AWS resources. Depending on the selected platform and configuration, the environment can include resources such as:

• Amazon EC2 instances
• An Auto Scaling group
• Elastic Load Balancing
• Platform runtimes and platform updates

Elastic Beanstalk does not eliminate all infrastructure access. Administrators can still access and customize the underlying instances when operational requirements demand it. However, the service automates much of the routine environment provisioning and management.

Elastic Beanstalk applications

An Elastic Beanstalk application is a logical container for related resources and deployment artifacts. It can contain:

• Application versions
• Environment configurations
• Multiple environments, such as development, test, and production

The application itself is not the running infrastructure. It organizes the versions and environments associated with an application.

Application versions

An application version identifies a specific deployable package of source code. Uploaded packages are stored in Amazon S3, while Elastic Beanstalk maintains references to those packages.

A version can be deployed to one or more environments. Because earlier versions remain available, a deployment can be rolled back by applying a previous version to an environment.

This separation between code versions and environments supports workflows such as:

• Deploying a new version to a development environment first
• Promoting the same version to production after validation
• Keeping production and development configurations independent
• Rolling back production to a previously known-good version

Elastic Beanstalk environments

An environment is the collection of AWS resources running a particular application version with a specific configuration. It is more than an EC2 instance containing application code.

An environment may include the compute instances, load balancing, scaling configuration, networking configuration, and platform runtime required by the application. Environment settings can be managed independently, allowing development and production to use different capacity, networking, scaling, and deployment settings.

When creating an environment, the customer specifies important placement and networking choices such as the VPC, subnets, and Availability Zones. Elastic Beanstalk then provisions the selected environment architecture.

Web server environments

A web server environment handles synchronous HTTP or HTTPS requests. It is typically placed behind a load balancer and uses an Auto Scaling group to provide capacity and availability.

Typical characteristics include:

• Receives requests from users or client applications
• Processes HTTP or HTTPS traffic
• Returns responses directly to callers
• Scales based on configured environment policies
• Commonly uses Elastic Load Balancing for request distribution

Web server environments are appropriate for request/response workloads where the client expects the application to complete processing during the request.

Worker environments

A worker environment is designed for asynchronous background processing. Instead of receiving user requests directly, workers retrieve messages from an Amazon SQS queue and process them.

A common flow is:

1. A client submits a request to the web application.
2. The web server validates the request and places a message in Amazon SQS.
3. Worker instances poll the queue.
4. A worker processes the message independently of the original web request.

Worker environments are useful for long-running or resource-intensive operations, such as order processing, report generation, media processing, or other tasks that should not keep an HTTP request open.

Moving this work out of the web tier improves responsiveness and allows the worker tier to scale based on queue demand rather than web traffic alone.

Supported application platforms

Elastic Beanstalk supports multiple application platforms and runtimes, including examples such as:

• Java
• .NET
• Node.js
• PHP
• Ruby
• Python
• Go
• Docker

The exact supported platform versions and configuration options change over time. For production deployments, verify current platform support and retirement schedules before selecting a runtime.

Exam-Relevant Takeaways

• Elastic Beanstalk is a PaaS deployment service, not a replacement for the application itself.
• Developers can deploy source code without manually building every EC2, Auto Scaling, and load-balancing component.
• Elastic Beanstalk environments can include EC2, Auto Scaling, and Elastic Load Balancing resources.
• An application is a logical container for versions, environments, and configurations.
• An application version refers to a deployable code package, commonly stored in Amazon S3.
• Multiple environments can run different versions of the same application.
• Rolling back can be performed by assigning an earlier application version to an environment.
• Web server environments handle HTTP or HTTPS requests.
• Worker environments consume Amazon SQS messages for asynchronous and long-running processing.
• Elastic Beanstalk provides managed platform updates, but organizations still need a strategy for testing and approving updates.
• Elastic Beanstalk provides access to the underlying operating system, unlike more restrictive fully managed application platforms.

Architecture Decision Guide

Requirement	Suitable Elastic Beanstalk approach	Reason
Standard request/response web application	Web server environment	Handles HTTP/HTTPS traffic and can use a load balancer and Auto Scaling group
Long-running background processing	Worker environment with Amazon SQS	Decouples processing from the user request and supports asynchronous execution
Separate development and production deployments	Multiple environments in one application	Each environment can use its own version and configuration
Safe rollback after a failed deployment	Retain multiple application versions	A previous version can be redeployed to the environment
Application team wants managed infrastructure but some OS access	Elastic Beanstalk	Automates platform provisioning while retaining instance-level access
Full control over the operating system and infrastructure	Amazon EC2 or another IaaS design	Elastic Beanstalk abstracts and manages much of the environment

Common Exam Traps

• Confusing an application with an environment: An application is the organizational container; an environment is the running set of AWS resources.
• Assuming Elastic Beanstalk is serverless: Elastic Beanstalk commonly provisions EC2 instances and related infrastructure. It is managed PaaS, not a serverless execution model.
• Treating a worker environment as another public web tier: Worker environments consume messages from Amazon SQS and are intended for background processing.
• Using web servers for long-running jobs: Long-running work can cause timeouts and poor user experience. Queue the work and process it asynchronously.
• Assuming Elastic Beanstalk removes all OS responsibilities: The service manages much of the platform, but customers may still have operating system and application-level responsibilities.
• Assuming every deployment automatically supports rollback: Rollback depends on retaining usable application versions and applying the desired version to the target environment.
• Overlooking environment-specific configuration: Development and production environments can run different versions and have different settings; configuration must be managed deliberately.
• Ignoring platform lifecycle management: Managed platform updates help apply runtime and patch updates, but updates should still be tested before production rollout.

Real-World Engineer Notes

• Treat application versions as immutable release artifacts. Build and test a package once, then promote that same version through environments.
• Use separate environments for development, testing, and production when their scaling, networking, or deployment requirements differ.
• Use a worker environment when the user does not need the result immediately or when processing could exceed normal HTTP request timeouts.
• Design queue consumers for retries and duplicate delivery. The application should be idempotent because asynchronous processing can require a message to be processed more than once.
• Keep platform updates under change control. Validate runtime changes in a nonproduction environment before applying them to production.
• Understand what Elastic Beanstalk creates on your behalf. The environment may include security groups, load balancing, Auto Scaling, EC2 instances, and networking choices that still require governance and monitoring.
• Elastic Beanstalk is useful when the team wants a conventional application platform with AWS resource access. It may be less suitable when the workload requires highly customized infrastructure or a container orchestration model.

Quick Reference Summary

• Elastic Beanstalk: Managed PaaS for deploying supported application platforms.
• Application: Logical container for environments, configurations, and application versions.
• Application version: A deployable source-code package, commonly backed by Amazon S3.
• Environment: Running AWS resources configured to host a selected application version.
• Web server environment: Processes HTTP/HTTPS requests.
• Worker environment: Polls Amazon SQS and performs asynchronous background work.
• Common underlying services: Amazon EC2, Auto Scaling, Elastic Load Balancing, and Amazon S3.
• Key operational benefit: Less platform management than raw EC2 while retaining access to the underlying environment.

Flashcards

1. Q: What type of service is Elastic Beanstalk?

A: A Platform as a Service offering that provisions and manages application environments on AWS.

1. Q: What remains the customer’s responsibility when using Amazon EC2 directly?

A: The operating system, runtime, application, patches, hardening, and much of the infrastructure configuration.

1. Q: What is an Elastic Beanstalk application?

A: A logical container for application versions, environments, and environment configurations.

1. Q: What is an application version?

A: A specific deployable package of application source code.

1. Q: Where are Elastic Beanstalk application packages commonly stored?

A: Amazon S3.

1. Q: What is an Elastic Beanstalk environment?

A: The collection of AWS resources running a selected application version with a particular configuration.

1. Q: What environment type handles normal HTTP or HTTPS requests?

A: A web server environment.

1. Q: What environment type is intended for asynchronous background work?

A: A worker environment that consumes messages from Amazon SQS.

1. Q: Why use a worker environment for long-running tasks?

A: It prevents lengthy processing from blocking the web request and allows background capacity to scale independently.

1. Q: How can an Elastic Beanstalk deployment be rolled back?

A: Apply a previously retained application version to the target environment.

1. Q: Does Elastic Beanstalk prevent access to the operating system?

A: No. It manages much of the platform but still permits underlying instance access when required.

1. Q: Can development and production environments use different application versions?

A: Yes. Versions and environment settings can be applied independently.

Practice Questions

Question 1

A company runs an online ordering application on Elastic Beanstalk. Customers report slow responses whenever large invoice files are generated. The architect wants to improve responsiveness without requiring customers to wait for invoice generation to complete. Which design best addresses the requirement?

Correct answer: Send invoice-generation requests to Amazon SQS and process them with an Elastic Beanstalk worker environment.

Explanation: The web server should acknowledge or track the request and place a message in the queue. Worker instances can perform the long-running task asynchronously, preventing the web tier from being blocked.

Question 2

A development team wants to deploy the same application to development and production. They need to test a new release in development while production continues running the current release. Which Elastic Beanstalk capability supports this design?

Correct answer: Maintain multiple application versions and deploy them independently to separate environments.

Explanation: Application versions are reusable deployment artifacts, while environments are independent running resource sets. Development can run the new version while production remains on the previous version.

Question 3

An organization wants a managed application platform but requires the ability to access the operating system for troubleshooting and specialized operational configuration. Which service best fits these requirements?

Correct answer: AWS Elastic Beanstalk.

Explanation: Elastic Beanstalk automates much of the provisioning and management of the application environment while retaining access to the underlying EC2-based infrastructure. A fully serverless service would not provide the same operating system access.

Question 4

A production deployment introduces a severe application defect. The previous release is still available as an Elastic Beanstalk application version. What is the fastest appropriate recovery action?

Correct answer: Deploy the previous known-good application version to the production environment.

Explanation: Elastic Beanstalk keeps references to uploaded application packages, allowing an earlier version to be reapplied to an environment for rollback.

Question 5

An architect must choose between deploying an application directly to EC2 and using Elastic Beanstalk. The team wants AWS to provision the compute, scaling, load balancing, and runtime platform, but it also needs some instance-level access. Which choice is most appropriate?

Correct answer: Elastic Beanstalk.

Explanation: Direct EC2 provides maximum infrastructure control but requires the team to manage more of the operating system and platform. Elastic Beanstalk automates the common environment components while preserving access to the underlying instances.