Phase 4: Infrastructure as Code & Cloud

ECS, EKS, Lambda & RDS

Intermediate ~2 min read
Think of it this way A friendly analogy. Read this if the technical version feels dense. Show Hide

Imagine you're running a super busy restaurant, making lots of different yummy dishes for many customers. In the world of computers, programs and apps are like these dishes. To make sure everything runs smoothly, especially when you have tons of dishes (programs) to make all at once, you need a good system.

This is where ECS (Elastic Container Service) and EKS (Elastic Kubernetes Service) come in. Think of them as two different kinds of amazing kitchen managers for your restaurant. Each dish or part of your app comes in a little, self-contained "meal kit" (that's what we call a "container" in computer talk). These kitchen managers decide which kits to make, how many, when to start them, and where to put them so everything gets done efficiently. ECS is like a manager who knows your restaurant's kitchen perfectly and uses its special tools to make dishes super fast and easy. EKS is like a manager who uses a widely known, universal system that could work in any restaurant kitchen. It might take a little more learning, but if you want the flexibility to move your cooking system to other places, it's a great choice. Both help you make sure all your "dishes" are prepared and served perfectly, no matter how busy it gets.

Sometimes, you have a really tiny job, like just cracking an egg for one dish, or putting a single cherry on top of a dessert. For these small, quick tasks, you don't need to fire up the whole kitchen. That's where AWS Lambda comes in. It's like having a magic helper who appears just to do that one tiny job, instantly, and then vanishes until the next time you need them. You just give them the recipe for the small task, and they do it without you ever needing to worry about the kitchen or the stove itself. For example, if someone signs up for your app, Lambda could be the magic helper that quickly sends them a "welcome" email.

Finally, every good restaurant needs a super organized, very secure place to keep all its important information: the secret recipes, customer orders, ingredient lists, and even how many times each customer has visited. That's what RDS (Relational Database Service) is for. It's like a magical, indestructible recipe book and customer ledger that's always tidy, always backed up, and always easy for the kitchen staff to find exactly what they need, quickly and reliably.

So, when you're building a cool new website or an awesome game, these tools help you make sure your programs run smoothly, your small tasks are handled quickly, and all your important information is stored safely, making your app a big success!

For deploying containerized applications, AWS offers two primary orchestration services: ECS (Elastic Container Service) and EKS (Elastic Kubernetes Service). ECS is AWS's native container orchestrator, often simpler to set up and manage, especially if you're fully invested in the AWS ecosystem. It integrates seamlessly with other AWS services and can leverage Fargate, a serverless compute engine that eliminates the need to manage EC2 instances for your containers. EKS, on the other hand, is a managed Kubernetes service. It's the go-to choice if your team already uses Kubernetes, requires multi-cloud portability, or prefers standard Kubernetes APIs and tooling. While EKS offers greater flexibility and ecosystem compatibility, it generally involves a steeper learning curve and more operational overhead than ECS, even with Fargate. Both allow you to run Docker containers at scale, choosing based on your operational preference and existing Kubernetes expertise.

Moving beyond containers, AWS Lambda provides a serverless compute service, allowing you to run code without provisioning or managing servers. You simply upload your code (a "function"), and Lambda executes it in response to events – such as HTTP requests via API Gateway, file uploads to S3, or scheduled timers. This event-driven model makes Lambda ideal for microservices, API backends, data processing, and automation tasks that are stateless and typically short-lived. It scales automatically to handle varying loads and you only pay for the compute time consumed, making it highly cost-effective for many use cases where traditional servers might be underutilized.

Finally, Amazon RDS (Relational Database Service) simplifies the setup, operation, and scaling of relational databases in the cloud. RDS manages the underlying infrastructure, handling tasks like backups, patching, scaling, and high availability for popular database engines such as PostgreSQL, MySQL, SQL Server, and Oracle. As a DevOps engineer, RDS frees you from tedious database administration, allowing you to focus on application development and deployment. These services often work in concert: your application might run on ECS or EKS, serve requests via an API Gateway backed by Lambda functions, and persist data in a managed RDS instance. Understanding how to integrate them is crucial for building robust, scalable, and maintainable cloud applications.

Key Takeaways

  • ECS vs. EKS: Choose ECS for AWS-native simplicity or EKS for standard Kubernetes and multi-cloud flexibility; both run containers.
  • Lambda: Ideal for event-driven, serverless functions, scaling automatically and charged per execution.
  • RDS: Provides fully managed relational databases (e.g., PostgreSQL, MySQL), significantly reducing operational overhead.
  • These services are fundamental building blocks for modern cloud applications, often integrated to create complete, scalable architectures.

Code Example

yaml
service: my-serverless-api

provider:
  name: aws
  runtime: nodejs18.x
  region: us-east-1
  memorySize: 128

functions:
  helloWorld:
    handler: handler.hello
    events:
      - httpApi:
          path: /hello
          method: get

How this code works

This code sets up a basic serverless web endpoint using AWS Lambda, ready to respond to web requests. It's a foundational example of building an API without managing servers, a core concept in the lesson covering ECS, EKS, Lambda & RDS.

The service: my-serverless-api line gives the project a name. The provider section configures the deployment environment: name: aws specifies Amazon Web Services, runtime: nodejs18.x dictates the programming language environment, and region: us-east-1 sets the geographic location. memorySize: 128 allocates 128MB of RAM for the function to execute. Under functions, helloWorld defines a specific serverless function. Its handler: handler.hello indicates the JavaScript file (handler.js) and the exported function (hello) that contains the logic. The events section specifies how this function is invoked. Here, httpApi creates an API Gateway endpoint, making the function accessible via the web. Specifically, it responds to GET requests sent to the /hello path. A subtle but important detail for beginners is that httpApi uses the newer, simpler, and often cheaper API Gateway v2 (HTTP API) instead of the older REST API, which is a great default for most new projects.

Related Articles

Hand-picked reads to go deeper on aws core services.

Back to DevOps Engineer Roadmap