Amazon Web Services

Author the Lambda function handler with entry point and dependencies.

Bundle handler code and dependencies into a .zip deployment package.

Create or update the Lambda function with the packaged artifact.

Attach an event source such as API Gateway, S3, or SQS to invoke the function.

Invoke the function with a sample event and verify the response.

Launch an instance from the chosen AMI with the specified instance type and key pair.

Create or update the security group to allow SSH, HTTP, and HTTPS inbound traffic.

Connect to the running instance via SSH and verify access.

Install required packages and configure the instance environment.

Create an Amazon Machine Image from the configured instance for future use.

Register a Fargate task definition with container image, CPU, memory, and port mappings.

Create the ECS service in a Fargate cluster with desired task count and networking.

Create or update the ALB target group and listener rules to route traffic to the service.

Force a new deployment to roll out the latest task definition.

Verify the service is healthy via ALB health check endpoint.

Create the Elastic Beanstalk application with the target platform.

Create an environment with instance type, scaling, and environment variable configuration.

Upload and deploy the application version to the environment.

Monitor environment health status and ensure all instances pass health checks.

Swap CNAMEs between staging and production environments for blue-green deployment.

Create a new S3 bucket with the specified region and naming.

Apply a bucket policy to control access permissions.

Upload a file to the bucket with optional metadata and storage class.

Configure lifecycle rules for automatic transitions to cheaper storage classes and expiration.

Enable bucket versioning to preserve, retrieve, and restore every version of every object.

Create an encrypted EFS file system with the chosen performance mode.

Create mount targets in each availability zone subnet with security group access.

Install amazon-efs-utils and mount the file system on the EC2 instance via NFS.

Write and read a test file to verify the mount is functional.

Create a new Glacier vault with notifications configured for retrieval jobs.

Upload data to the vault as an archive, receiving an archive ID.

Configure the vault data retrieval policy (free tier, max retrieval rate, or no limit).

Initiate a retrieval job, wait for completion, then download the archive.

Delete the archive from the vault after successful retrieval.

Create a table with the specified partition key, sort key, and billing mode.

Design the partition key, sort key, and any global secondary indexes for the access patterns.

Insert a sample item into the table to verify the schema.

Run a query against the table using the key condition expression.

Set up auto-scaling policies for read and write capacity units.

Provision an RDS instance with the chosen engine (PostgreSQL, MySQL, etc.), storage, and instance class.

Update the VPC security group to allow inbound connections on the database port.

Establish a connection using the database endpoint, credentials, and SSL.

Execute schema migrations to set up tables, indexes, and seed data.

Create a read replica in the same or different region for read scaling.

Create an Aurora DB cluster with engine version, VPC subnet group, and encryption settings.

Add a writer instance to the cluster with the specified instance class.

Connect to the cluster writer endpoint and verify read/write access.

Trigger a failover and verify the replica is promoted to writer within the expected window.

Run read queries against the reader endpoint and confirm data consistency after failover.

Provision a Redshift cluster with the chosen node type and number of nodes.

Connect and create the database schema with distribution and sort keys.

Use the COPY command to bulk-load data from S3 into the Redshift tables.

Execute analytical SQL queries against the loaded data and review results.

Use the UNLOAD command to export query results back to S3 in Parquet or CSV format.

Create a Redis or Memcached cluster with the specified node type and replication settings.

Apply a custom parameter group with eviction policy, max memory, and timeout settings.

Establish a connection from the application using the primary endpoint and auth token.

Perform SET and GET operations to verify cache read/write functionality.

Check CloudWatch metrics for cache hit rate, CPU utilization, and evictions.

Launch a SageMaker notebook instance with the chosen instance type and IAM role.

Upload training data to S3 and configure the data channels for the training job.

Create and run a training job with the specified algorithm, hyperparameters, and instance configuration.

Create a model, endpoint configuration, and deploy the trained model to a real-time endpoint.

Send a sample inference request to the endpoint and validate the response.

Choose from available models (Claude, Titan, Llama, etc.) based on task requirements.

Set temperature, max tokens, top-p, and stop sequences for the invocation.

Send the prompt to the Bedrock InvokeModel API and receive the completion.

Extract and structure the model output from the API response body.

Use InvokeModelWithResponseStream for real-time token streaming and process chunks.

Upload the target image to an S3 bucket for Rekognition to process.

Call DetectLabels to identify objects, scenes, and activities in the image.

Call DetectFaces to find faces and get attributes like age range, emotions, and landmarks.

Call CompareFaces to match faces between a source and target image.

Call DetectModerationLabels to flag inappropriate or unsafe content.

Prepare and submit the text document for analysis.

Call DetectSentiment to determine if the text is positive, negative, neutral, or mixed.

Call DetectEntities to extract people, places, organizations, dates, and quantities.

Call DetectDominantLanguage to identify the primary language of the text.

Call DetectPiiEntities to find personally identifiable information such as names, addresses, and SSNs.

Create a standard or FIFO queue with visibility timeout and retention settings.

Send a message to the queue with an optional message group ID and deduplication ID.

Poll the queue with long polling and receive messages with attributes.

Parse and handle the message payload according to business logic.

Delete the successfully processed message from the queue using its receipt handle.

Create a DLQ and set the redrive policy with max receive count.

Create a standard or FIFO topic with optional server-side encryption.

Subscribe endpoints (SQS, Lambda, HTTP, email) to the topic with filter policies.

Publish a message to the topic with optional message attributes and subject.

Verify that all subscribers received the message and processed it independently.

Check CloudWatch delivery status logs to confirm successful delivery to all endpoints.

Create a custom event bus for application-specific events.

Define an event pattern rule that matches specific event sources and detail types.

Attach targets (Lambda, SQS, Step Functions, etc.) to the rule with input transformation.

Publish a test event to the bus using PutEvents and verify it matches the rule.

Check CloudWatch metrics for matched events, failed invocations, and delivery latency.

Create a CodePipeline with the service role and artifact store.

Configure the source stage to pull from CodeCommit, GitHub, or S3.

Add a CodeBuild action to compile, test, and package the application.

Configure deployment to ECS, Lambda, Elastic Beanstalk, or CloudFormation.

Start a pipeline execution manually or via source change detection.

Monitor pipeline execution status and review action logs for each stage.

Create a project with source location, environment image, compute type, and service role.

Author the buildspec.yml with install, pre-build, build, and post-build phases.

Start a build with optional environment variable overrides.

Stream or retrieve the CloudWatch build logs to monitor progress.

Download the build artifacts from the configured S3 output bucket.

Author the YAML or JSON template defining the AWS resources and their configurations.

Create the CloudFormation stack from the template with parameters and IAM capabilities.

Poll stack events to track resource creation progress and catch failures early.

Update the stack with template changes, using change sets for safe review before execution.

Run drift detection to find resources that have been modified outside of CloudFormation.

Create a Cognito user pool with password policy, MFA settings, and attribute schema.

Set up the app client, hosted UI, callback URLs, and identity providers.

Authenticate a user with InitiateAuth and receive ID, access, and refresh tokens.

Decode and verify the JWT token signature, expiration, and claims against the JWKS endpoint.

Use the refresh token to obtain new ID and access tokens before expiration.

Author the Amazon States Language (ASL) definition with Task, Choice, Parallel, and Wait states.

Create the state machine in AWS with the ASL definition and execution role.

Start an execution with JSON input and receive the execution ARN.

Poll the execution history to track state transitions and verify each step completes.

Analyze failed states, configure Retry and Catch blocks, and update the state machine.

Create a schedule with a cron or rate expression and optional flexible time window.

Configure the target (Lambda, SQS, Step Functions, etc.) with the invocation payload.

Set the maximum retry attempts, maximum event age, and dead-letter queue for failed invocations.

Set the schedule state to ENABLED and confirm it is active.

Check CloudWatch metrics and logs to verify the schedule fires on time and the target is invoked.