Mastering Artifact Preparation for AWS Deployment

Preparing application artifacts is the critical bridge between writing source code and running a functional application in the cloud. In the AWS Certified Developer - Associate (DVA-C02) exam, this topic covers how you package code, manage dependencies, and configure environment-specific settings.

Learning Objectives

After studying this guide, you should be able to:

• Manage dependencies using environment variables, configuration files, and container images.
• Organize file and directory structures optimized for AWS deployment services.
• Define build processes using buildspec.yml for AWS CodeBuild.
• Allocate resource requirements (CPU, memory) based on application needs.
• Configure environment-specific parameters using AWS AppConfig and Systems Manager.

Key Terms & Glossary

• Artifact: A compiled or packaged version of your application code (e.g., a .zip file, a JAR, or a Docker image) ready for deployment.
• Buildspec: A collection of build commands and related settings, in YAML format, that AWS CodeBuild uses to run a build.
• Environment Variables: Dynamic-named values that can affect the way running processes will behave on a computer, used to keep secrets and configurations out of code.
• Lambda Layer: A distribution mechanism for libraries, custom runtimes, and other function dependencies to keep deployment packages small.
• AWS AppConfig: A service used to create, manage, and quickly deploy application configurations separately from code.

The "Big Idea"

[!IMPORTANT] The goal of artifact preparation is to create an immutable deployment unit. Once an artifact is built (e.g., in a "Build" stage), it should remain unchanged as it moves through Staging and into Production. Only the environment-specific configurations (provided by services like AppConfig or Parameter Store) should change.

Formula / Concept Box

Hierarchical Outline

1. Dependency Management
   • External Libraries: Managed via package.json (Node), requirements.txt (Python), or pom.xml (Java).
   • Lambda Layers: Shared dependencies across multiple functions.
   • Container Images: Bundling the OS, runtime, and code into a single OCI-compliant image.
2. Build Lifecycle (The buildspec.yml)
   • Install Phase: Installing runtimes or packages (e.g., npm install).
   • Pre-build: Logging into ECR or running unit tests.
   • Build: Compiling code or building Docker images.
   • Post-build: Packaging artifacts and uploading to S3.
3. Environment Preparation
   • AWS AppConfig: Feature flags and runtime configuration updates.
   • Resource Sizing: Mapping memory (128MB - 10GB for Lambda) to proportional CPU power.

Visual Anchors

The Buildspec Lifecycle

Resource Allocation Concept

\begin{tikzpicture}[scale=0.8] \draw[thick, ->] (0,0) -- (6,0) node[right] {Memory (MB)}; \draw[thick, ->] (0,0) -- (0,4) node[above] {CPU Power}; \draw[blue, ultra thick] (0.5,0.5) -- (5,3.5); \node at (3,2) [rotate=32, anchor=south] {Linear Scaling}; \filldraw[red] (1,0.8) circle (2pt) node[anchor=north west] {128MB / low CPU}; \filldraw[green!60!black] (4.5,3.1) circle (2pt) node[anchor=south east] {10GB / 6 vCPUs}; \end{tikzpicture}

Definition-Example Pairs

• Definition: Environment Variables are key-value pairs stored in the execution environment rather than hardcoded.
  • Real-World Example: Storing DB_ENDPOINT as an environment variable so the same code connects to dev-db.aws.com in development and prod-db.aws.com in production.
• Definition: Artifact Mapping is the process of defining which files from a build should be kept for deployment.
  • Real-World Example: In a React project, the buildspec.yml specifies the /build directory as the artifact, ignoring the heavy node_modules folder.

Worked Examples

Creating a buildspec.yml for a Node.js Lambda

To prepare a Lambda artifact, you must define the phases in a buildspec.yml file located in the root of your source repository.

[!TIP] Use discard-paths: yes if you want the artifact to be placed in the root of the S3 destination without replicating the source folder structure.

Checkpoint Questions

1. Which file is required by AWS CodeBuild to define the build commands and artifact locations?
2. If your Lambda function requires a 50MB shared library used by ten other functions, what is the best way to package this library?
3. In which phase of the buildspec.yml would you typically run unit tests?
4. True or False: Increasing the memory allocation for an AWS Lambda function also increases its available CPU capacity.
5. Which service would you use to manage "Feature Flags" that can be toggled without redeploying code?

▶Click to see answers

1. buildspec.yml
2. As a Lambda Layer.
3. The pre_build phase.
4. True. CPU scales linearly with memory in Lambda.
5. AWS AppConfig.