Skip to content

Elastic Beanstalk

AWS Elastic Beanstalk Overview

  • Definition: AWS Elastic Beanstalk is a Platform-as-a-Service (PaaS) that simplifies deploying, scaling, and managing web applications and services by handling infrastructure provisioning and operations.
  • Key Features:
    • Supports multiple languages/platforms (e.g., Java, .NET, Python, Node.js, Ruby, PHP, Go, Docker).
    • Automates EC2, Auto Scaling, ELB, and monitoring setup.
    • Offers flexibility to customize infrastructure (e.g., instance types, VPC).
    • Managed updates and deployments.
  • Use Cases: Web applications, APIs, microservices, rapid prototyping.

1. Elastic Beanstalk Core Concepts

Components

  • Application:
    • Logical container for environments and versions.
    • Explanation: E.g., MyApp holds all app-related resources.
  • Application Version:
    • Specific release of the application code (e.g., ZIP, WAR, Docker image).
    • Stored in S3.
    • Explanation: E.g., v1.0 with app.zip.
  • Environment:
    • Running instance of an application version (e.g., prod, dev).
    • Types:
      • Web Server: Handles HTTP requests (e.g., with ALB).
      • Worker: Processes background tasks (e.g., with SQS).
    • Explanation: E.g., MyApp-prod runs v1.0 with EC2 and ALB.
  • Environment Configuration:
    • Settings for infrastructure (e.g., instance type, scaling, ELB).
    • Saved as templates for reuse.
    • Explanation: E.g., configure t3.micro, min 2 instances.
  • Platform:
    • Combination of OS, runtime, and server software (e.g., Python 3.8 on Amazon Linux 2).
    • Explanation: E.g., Node.js 18 with Nginx.

Deployment Options

  • All-at-Once: Deploys new version to all instances simultaneously (fastest, causes downtime).
  • Rolling: Updates instances in batches (no downtime, slower).
  • Rolling with Additional Batch: Adds new instances, updates in batches, removes old (no downtime, more resources).
  • Immutable: Launches new instances with new version, swaps, terminates old (no downtime, safest).
  • Blue/Green: Creates new environment, swaps CNAME (no downtime, full control).
  • Explanation: E.g., use immutable for production to avoid outages.

Key Notes:

  • Exam Relevance: Understand components, deployment types, and platform support.
  • Mastery Tip: Practice deploying a simple app with different deployment policies.

2. Elastic Beanstalk Performance Features

Elastic Beanstalk supports high-performing applications.

Auto Scaling

  • Purpose: Adjust capacity dynamically.
  • Features:
    • Uses EC2 Auto Scaling group with min/max/desired instances.
    • Scales based on metrics (e.g., CPUUtilization, RequestCount).
    • Explanation: E.g., scale out to 10 instances if CPU > 70%.
  • Configuration: Set scaling triggers (e.g., target 500 requests per instance).
  • Explanation: Simplifies scaling—managed by Beanstalk.

Load Balancing

  • Purpose: Distribute traffic.
  • Features:
    • Uses Application Load Balancer (ALB) or Classic Load Balancer (legacy).
    • Supports path-based routing, WebSocket.
    • Explanation: E.g., ALB routes /api to instances.

Managed Platforms:

  • Purpose: Optimize runtimes.
  • Features: Pre-configured OS, web servers (e.g., Nginx, Apache), and runtimes.
  • Explanation: E.g., Python 3.8 optimized for Flask apps.

Key Notes:

  • Performance: Auto Scaling + ALB = responsive apps.
  • Exam Tip: Know how to configure scaling triggers and ALB health checks.

3. Elastic Beanstalk Resilience Features

Resilience ensures application availability.

Multi-AZ Deployment

  • Purpose: Survive AZ failures.
  • How It Works:
    • Instances spread across AZs via Auto Scaling.
    • ALB routes traffic to healthy instances.
  • Explanation: E.g., 4 instances across us-east-1a, us-east-1b.

Health Monitoring

  • Purpose: Replace failed instances.
  • Features:
    • Enhanced health monitoring (application-level checks).
    • EC2 status checks (system-level).
    • Explanation: E.g., restart instance if HTTP 500 errors exceed threshold.
  • Health Dashboard: Shows environment status (Green, Yellow, Red).
  • Explanation: E.g., Yellow if scaling is needed.

Managed Updates

  • Purpose: Keep platform secure.
  • Features:
    • Automatic platform updates (e.g., OS patches) during maintenance windows.
    • Option to defer or customize updates.
  • Explanation: E.g., patch Amazon Linux 2 weekly.

Deployment Resilience

  • Purpose: Avoid outages during updates.
  • Features: Rolling, Immutable, Blue/Green deployments minimize downtime.
  • Explanation: E.g., immutable ensures zero downtime for version upgrades.

Key Notes:

  • Resilience: Multi-AZ + health checks = high availability.
  • Exam Tip: Compare deployment types for resilience (e.g., Immutable vs. All-at-Once).

4. Elastic Beanstalk Security Features

Security aligns with SAA-C03’s secure architecture focus.

Encryption

  • At Rest:
    • EBS volumes encrypted with KMS.
    • S3 buckets for app versions encrypted.
  • In Transit:
    • HTTPS via ALB (with ACM certificates).
    • Explanation: E.g., enforce SSL for client traffic.
  • Explanation: Meets compliance—e.g., GDPR, HIPAA.

Access Control

  • IAM:
    • Service Role: Allows Beanstalk to manage resources (e.g., aws-elasticbeanstalk-service-role).
    • Instance Role: Grants EC2 access to AWS services (e.g., s3:GetObject).
    • Example: {"Effect": "Allow", "Action": "sqs:SendMessage", "Resource": "arn:aws:sqs:us-east-1:123456789012:worker-queue"}.
  • User Policies: Control access to Beanstalk (e.g., elasticbeanstalk:CreateEnvironment).
  • Explanation: Least privilege—e.g., restrict developers to read-only.

VPC:

  • Purpose: Isolate resources.
  • Features:
    • Deploy instances in private subnets, ALB in public subnets.
    • Security groups for fine-grained control.
  • Explanation: E.g., allow port 80 from ALB only.

Secrets Management

  • Purpose: Secure credentials.
  • Features: Integrate with Secrets Manager or SSM Parameter Store via .ebextensions.
  • Explanation: E.g., store DB password securely.

Key Notes:

  • Security: KMS + IAM + VPC = secure apps.
  • Exam Tip: Practice IAM roles and security group configs.

5. Elastic Beanstalk Cost Optimization

Cost efficiency is a key exam domain.

Pricing

  • Elastic Beanstalk: Free (pay for underlying resources).
  • Resources:
    • EC2: ~$0.096/hour (m5.large).
    • ALB: ~$0.0225/hour + $0.008/GB processed.
    • S3: ~$0.023/GB-month for app versions.
    • CloudWatch, Auto Scaling: Standard rates.
  • Free Tier: 750 hours/month of t2/t3.micro (shared with EC2).
  • Example: Environment with 2 t3.micro, ALB = ~$2.40/day.

Cost Strategies

  • Instance Sizing:
    • Use t3/t4g for burstable performance.
    • Reserved Instances for steady-state (~50% savings).
    • Explanation: E.g., t3.micro for dev environments.
  • Auto Scaling:
    • Set conservative min/max (e.g., min=1, max=4).
    • Use Target Tracking to avoid over-provisioning.
    • Explanation: E.g., scale only when CPU > 50%.
  • Spot Instances:
    • Enable Spot in Auto Scaling group (via launch template).
    • Explanation: E.g., 70% savings for non-critical apps.
  • Clean Up:
    • Delete old app versions from S3.
    • Terminate unused environments.
    • Explanation: E.g., avoid S3 storage costs.

Key Notes:

  • Cost Savings: t3 + Spot + Auto Scaling = low costs.
  • Exam Tip: Calculate costs for a web app with ALB and Auto Scaling.

6. Elastic Beanstalk Advanced Features

.ebextensions

  • Purpose: Customize infrastructure.
  • Features: YAML/JSON files to configure resources (e.g., install packages, create SQS queues).
  • Example: Install Nginx module via commands in .ebextensions/options.config.
  • Explanation: Extends Beanstalk—e.g., set up cron jobs.

Worker Environments

  • Purpose: Process background tasks.
  • Features:
    • Polls SQS queue, executes tasks.
    • Scales independently of web tier.
  • Explanation: E.g., process image uploads asynchronously.

Blue/Green Deployments

  • Purpose: Zero-downtime updates.
  • Features: Swap CNAME between environments (prod → staging).
  • Explanation: E.g., test new version before swapping.

Custom Platforms

  • Purpose: Support non-standard stacks.
  • Features: Define custom AMIs for unique runtimes.
  • Explanation: E.g., run a legacy app on custom OS.

Key Notes:

  • Flexibility: .ebextensions + worker tiers = versatile apps.
  • Exam Tip: Know .ebextensions for customizations.

7. Elastic Beanstalk Use Cases

Understand practical applications.

Web Applications

  • Setup: Web server environment + ALB + Python.
  • Features: Auto Scaling, managed updates.
  • Explanation: E.g., Flask-based e-commerce site.

Microservices

  • Setup: Multiple environments + Docker.
  • Features: Independent scaling per service.
  • Explanation: E.g., payment API separate from catalog API.

Background Processing

  • Setup: Worker environment + SQS.
  • Features: Process tasks asynchronously.
  • Explanation: E.g., email notifications.

Prototyping

  • Setup: Single instance + Node.js.
  • Features: Quick deployment, Free Tier.
  • Explanation: E.g., MVP for a startup.

8. Elastic Beanstalk vs. Other Services

Feature Elastic Beanstalk EC2 Auto Scaling ECS/Fargate
Type PaaS Instance Scaling Container Orchestration
Workload Web/worker apps EC2-based apps Containerized apps
Management High-level Granular Container-focused
Cost Resource-based EC2-based vCPU + memory
Use Case Simplified deployment Custom scaling Container management

Explanation:

  • Elastic Beanstalk: Managed PaaS for quick app deployment.
  • EC2 Auto Scaling: Granular control for EC2 fleets.
  • ECS/Fargate: Container orchestration, serverless options.

Detailed Explanations for Mastery

  • Immutable Deployment:
    • Example: Deploy v2.0; new instances launch, swap, old terminate.
    • Why It Matters: Zero downtime—exam favorite for production.
  • .ebextensions:
    • Example: Create SQS queue via Resources in .ebextensions.
    • Why It Matters: Customizes infra—common SAA-C03 scenario.
  • Worker Tier:
    • Example: Poll SQS, process image, save to S3.
    • Why It Matters: Separates workloads—key for scalability.

Quick Reference Table

Feature Purpose Key Detail Exam Relevance
Application/Environment Organize apps Web server, worker tiers Core Concept
Deployment Types Update apps Immutable, Blue/Green Resilience
Auto Scaling Maintain performance CPU, request-based triggers Performance
ALB Distribute traffic Path-based routing Performance
Multi-AZ High availability Spread instances across AZs Resilience
Encryption/IAM Security KMS, service/instance roles Security
Spot Instances Cost savings Enable in Auto Scaling Cost
.ebextensions Customize infra YAML/JSON configs Flexibility