Complete AWS Tutorial - GUI Version

1. What is AWS?

Amazon Web Services (AWS) is the world's most comprehensive and broadly adopted cloud platform, offering over 200 fully featured services from data centers globally. Millions of customers—including the fastest-growing startups, largest enterprises, and leading government agencies—are using AWS to lower costs, become more agile, and innovate faster.

AWS provides on-demand delivery of compute power, database storage, applications, and other IT resources via the internet with pay-as-you-go pricing.

Key Advantages of Cloud Computing (AWS):

• Agility: Rapidly spin up resources as needed.
• Elasticity/Scalability: Scale resources up or down automatically based on demand.
• Cost-Effectiveness: Pay only for what you use, eliminating large upfront hardware investments.
• Global Reach: Deploy applications globally in minutes.
• Reliability: Highly reliable infrastructure with built-in redundancy.
• Security: Benefit from AWS's robust security measures and compliance certifications.

2. AWS Global Infrastructure

AWS operates a highly available and resilient infrastructure to serve its global customer base.

• Regions: Geographic locations around the world where AWS clusters data centers. Each region is a separate, isolated geographical area. Examples: `US East (N. Virginia)`, `Europe (Ireland)`, `Asia Pacific (Singapore)`.
• Availability Zones (AZs): Isolated locations within a Region. Each AZ is physically distinct, with independent power, cooling, and networking, designed to be isolated from failures in other AZs. They are connected by low-latency links.
• Local Zones: Extensions of an AWS Region that place compute, storage, database, and other select services closer to large population, industry, and IT centers.
• Wavelength Zones: Deliver AWS services at the edge of the 5G network, enabling ultra-low latency applications.
• Edge Locations (CloudFront): Data centers operated by AWS that cache content closer to end-users globally, reducing latency for content delivery.

3. Getting Started with AWS

A. Create an AWS Account:

Go to aws.amazon.com and click "Create an AWS Account." You'll need an email address, password, credit card (for verification, you won't be charged for Free Tier usage), and a phone number.

Steps for setting up MFA on AWS root account (GUI):

1. Log in to AWS Management Console as the root user.
2. In the top right, click on your account name (e.g., "Root user") and select **Security credentials**.
3. Under "Multi-factor authentication (MFA)", click **Activate MFA**.
4. Choose **Authenticator app** (e.g., Google Authenticator, Authy) and click **Next**.
5. Follow the on-screen instructions to scan the QR code with your authenticator app and enter two consecutive MFA codes. Click **Add MFA**.

B. The AWS Management Console:

This is the web-based interface for managing your AWS resources. This tutorial will focus on using the Console GUI.

# Access: https://aws.amazon.com/console/

Upon logging in, you'll see the **AWS Management Console Home**, providing a search bar for services and links to recently visited services.

C. AWS Free Tier:

Offers free usage of many AWS services for new accounts (typically for 12 months) up to certain limits. Great for learning and experimenting without incurring costs. Always check the AWS Free Tier page for current limits.

4. Compute Services

These services provide the computing power for your applications.

A. Amazon EC2 (Elastic Compute Cloud) - GUI Usage:

Provides resizable compute capacity in the cloud (virtual servers).

1. Navigate to EC2:

   AWS Management Console > Search for "EC2" > Select EC2 under Services

2. Launch an Instance:
   • In the EC2 Dashboard, click **Launch instance** (or "Launch instances").
   • Name and tags: Provide a **Name** (e.g., `MyWebServer`).
   • Application and OS Images (Amazon Machine Image - AMI): Choose an AMI (e.g., `Amazon Linux`, `Ubuntu`, `Windows`). Select the **Free tier eligible** option if available.
   • Instance type: Select an instance type (e.g., `t2.micro` for Free Tier).
   • Key pair (login): Click **Create new key pair**. Give it a name (e.g., `my-ec2-key`), choose `RSA` and `.pem`. Click **Create key pair**. The `.pem` file will download; store it securely. You'll use this for SSH.
   • Network settings:
     • **Firewall (security groups):** Select **Create security group**. Give it a name (e.g., `my-web-sg`).
     • Check "Allow SSH traffic from" (select `My IP` or `Anywhere` for testing).
     • Check "Allow HTTP traffic from the Internet" (and HTTPS if needed).
   • Configure storage: Default 8GB is usually fine for `t2.micro`.
   • Advanced details: (Optional) Scroll down to "User data" to paste a script that runs on instance launch.

     #!/bin/bash
     sudo yum update -y # For Amazon Linux
     sudo yum install -y nginx
     sudo systemctl start nginx
     sudo systemctl enable nginx

   • Click **Launch instance**.
3. Connect to the EC2 Instance:
   • Once the instance state is "Running," click on its Instance ID.
   • Click the **Connect** button.
   • Choose the **EC2 Instance Connect** tab (simplest, uses browser). Click **Connect**.
   • Alternatively, use the **SSH client** tab for instructions on connecting from your local terminal using the `.pem` file.

B. AWS Lambda (Serverless Compute) - GUI Usage:

Runs code without provisioning or managing servers. You only pay for the compute time consumed.

1. Navigate to Lambda:

   AWS Management Console > Search for "Lambda" > Select Lambda under Services

2. Create a Function:
   • Click **Create function**.
   • Author from scratch:
     • Function name: (e.g., `MyS3Processor`).
     • Runtime: (e.g., `Python 3.9`).
     • Architecture: (e.g., `x86_64`).
     • Change default execution role: Select "Create a new role with basic Lambda permissions". This role allows your function to log to CloudWatch.
   • Click **Create function**.
3. Add Trigger (e.g., S3):
   • In the Function overview page, click **Add trigger**.
   • Select `S3` as the trigger configuration.
   • Bucket: Select an existing S3 bucket or create a new one (e.g., `my-lambda-trigger-bucket-2025`).
   • Event types: (e.g., `All object create events`).
   • Check "Enable trigger".
   • Click **Add**.
4. Write/Edit Function Code:
   • In the "Code" tab of your function, use the inline code editor.
   • Paste your function code (e.g., the Python code from the CLI tutorial).

   import json
   
   def lambda_handler(event, context):
       for record in event['Records']:
           bucket_name = record['s3']['bucket']['name']
           object_key = record['s3']['object']['key']
           file_size = record['s3']['object']['size']
           print(f"New object '{object_key}' uploaded to bucket '{bucket_name}' with size {file_size} bytes.")
           
       return {
           'statusCode': 200,
           'body': json.dumps('Lambda processed S3 event successfully!')
       }

   • Click **Deploy**.
5. Test: Upload a file to the S3 bucket you configured as a trigger. Go to the "Monitor" tab of your Lambda function and click "View CloudWatch logs" to see the output.

C. Amazon ECS (Elastic Container Service) - GUI Usage:

A fully managed container orchestration service that makes it easy to run, stop, and manage Docker containers on a cluster.

1. Navigate to ECS:

   AWS Management Console > Search for "ECS" > Select ECS under Services

2. Create Cluster & Task Definition & Service:
   • Go to **Clusters** > **Create Cluster**. Choose a networking configuration.
   • Go to **Task Definitions** > **Create new task definition**. Define your Docker container image, CPU, memory.
   • Go to **Services** > **Create**. Select your cluster, task definition, and configure desired count, load balancing.

D. Amazon EKS (Elastic Kubernetes Service) - GUI Usage:

A managed Kubernetes service that simplifies running Kubernetes on AWS.

1. Navigate to EKS:

   AWS Management Console > Search for "EKS" > Select EKS under Services

2. Create Cluster:
   • Go to **Clusters** > **Create cluster**.
   • Provide a **Name** and **Kubernetes version**.
   • Configure networking and logging.
   • Click **Create**.
3. Add Node Group: After cluster creation, add a node group (EC2 instances that will run your containers).

5. Storage Services

AWS offers various storage options for different use cases.

A. Amazon S3 (Simple Storage Service) - GUI Usage:

Object storage for the internet. Highly durable, available, and scalable.

1. Navigate to S3:

   AWS Management Console > Search for "S3" > Select S3 under Services

2. Create a Bucket:
   • Click **Create bucket**.
   • Bucket name: Enter a globally unique name (e.g., `my-unique-s3-bucket-2025-gui`).
   • AWS Region: Select a region.
   • (Optional) Configure Object Ownership, Block Public Access settings (default is to block all public access, which is recommended).
   • Click **Create bucket**.
3. Upload a File:
   • Click on your newly created bucket name.
   • Click **Upload**.
   • Click **Add files** or drag and drop files.
   • Click **Upload**.
4. Manage/Delete Files: On the bucket details page, you can select objects to download, delete, or change their properties. To delete the bucket, it must be empty first.

B. Amazon EBS (Elastic Block Store) - GUI Usage:

Block storage volumes for use with EC2 instances. Think of them as network-attached hard drives.

1. Navigate to EBS:

   AWS Management Console > EC2 > Elastic Block Store > Volumes

2. Create Volume:
   • Click **Create volume**.
   • Volume Type: (e.g., `gp3` General Purpose SSD).
   • Size: (e.g., `50 GiB`).
   • Availability Zone: Must be the same as the EC2 instance you'll attach it to.
   • Click **Create volume**.
3. Attach to Instance: Once created, select the volume, go to **Actions** > **Attach volume**. Choose your running EC2 instance.

C. Amazon EFS (Elastic File System) - GUI Usage:

Scalable file storage for use with EC2 instances and on-premises servers.

1. Navigate to EFS:

   AWS Management Console > Search for "EFS" > Select EFS under Services

2. Create File System:
   • Click **Create file system**.
   • Choose **VPC** (where your EC2 instances are).
   • Review and configure mount targets (defines network access points for the EFS).
   • Click **Create**.
3. Mount on EC2: Follow the instructions provided in the EFS console for connecting to your EC2 instance (e.g., installing `amazon-efs-utils` and mounting).

D. Amazon S3 Glacier - GUI Usage:

Extremely low-cost storage for data archiving and long-term backup.

1. Navigate to S3: (Glacier is a storage class within S3).

   AWS Management Console > S3 > Buckets

2. Upload to Glacier:
   • Create an S3 bucket or use an existing one.
   • Upload objects (files) to the bucket.
   • During upload, under "Storage class", select `S3 Glacier Instant Retrieval`, `S3 Glacier Flexible Retrieval`, or `S3 Glacier Deep Archive`.
   • Alternatively, use S3 Lifecycle Rules to transition older data from S3 Standard to Glacier automatically.

6. Networking Services

These services enable network connectivity and routing within and outside AWS.

A. Amazon VPC (Virtual Private Cloud) - GUI Usage:

Logically isolated section of the AWS Cloud where you can launch AWS resources in a virtual network that you define.

1. Navigate to VPC:

   AWS Management Console > Search for "VPC" > Select VPC under Services

2. Create VPC (using the wizard):
   • In the VPC Dashboard, click **Launch VPC wizard**.
   • Choose "VPC with a single public subnet" or "VPC with public and private subnets".
   • Provide a **VPC name** and **CIDR block** (e.g., `10.0.0.0/16`).
   • For subnets, define names and CIDR blocks (e.g., `10.0.1.0/24` for public, `10.0.2.0/24` for private).
   • The wizard will automatically create the Internet Gateway, Route Tables, and associate them.
   • Click **Create VPC**.
3. Security Groups: (Managed from EC2 console under "Security Groups" or VPC console under "Security").
4. Network ACLs (NACLs): (Managed from VPC console under "Security").

B. Amazon Route 53 - GUI Usage:

A highly available and scalable cloud Domain Name System (DNS) web service.

1. Navigate to Route 53:

   AWS Management Console > Search for "Route 53" > Select Route 53 under Services

2. Create Hosted Zone:
   • Click **Hosted zones** > **Create hosted zone**.
   • Domain name: Enter your domain (e.g., `yourcompany.com`).
   • Choose **Public hosted zone**.
   • Click **Create hosted zone**.
3. Create Record:
   • In your hosted zone, click **Create record**.
   • Choose **Record type** (e.g., `A` for IP address, `CNAME` for alias).
   • For A record: enter an **IP address** (e.g., your EC2 instance's EIP).
   • Click **Create records**.

C. Elastic Load Balancing (ELB) - GUI Usage:

Automatically distributes incoming application traffic across multiple targets, such as EC2 instances.

1. Navigate to EC2: (Load Balancers are configured under the EC2 service).

   AWS Management Console > EC2 > Load Balancing > Load Balancers

2. Create Load Balancer:
   • Click **Create Load Balancer**.
   • Choose a load balancer type (e.g., `Application Load Balancer` for HTTP/HTTPS, `Network Load Balancer` for high-performance TCP/UDP).
   • Follow the wizard to configure:
     • Name, **VPC**, **Availability Zones**.
     • Listeners (e.g., HTTP:80).
     • Target Groups: Create a new target group and register your EC2 instances.
   • Click **Create load balancer**.

D. Amazon CloudFront - GUI Usage:

A content delivery network (CDN) service that securely delivers data, videos, applications, and APIs to customers globally with low latency and high transfer speeds.

1. Navigate to CloudFront:

   AWS Management Console > Search for "CloudFront" > Select CloudFront under Services

2. Create Distribution:
   • Click **Create distribution**.
   • Origin domain: Select your S3 bucket (for static websites) or your Load Balancer/EC2 instance (for dynamic content).
   • Configure caching behaviors, SSL certificate.
   • Click **Create distribution**.

7. Database Services

AWS offers various managed database services.

A. Amazon RDS (Relational Database Service) - GUI Usage:

Makes it easy to set up, operate, and scale a relational database in the cloud.

1. Navigate to RDS:

   AWS Management Console > Search for "RDS" > Select RDS under Services

2. Create Database:
   • Click **Create database**.
   • Engine options: Choose a database engine (e.g., `MySQL`).
   • Templates: Select `Free tier` for learning.
   • DB instance identifier: (e.g., `mydbinstance`).
   • Master username & password: Set credentials.
   • Connectivity: Choose the VPC and Subnet group. For "Publicly accessible," select **Yes** for testing (No is recommended for production).
   • VPC security group: Select "Choose existing" and pick the security group that allows access from your EC2 instances (or your IP for testing).
   • Click **Create database**.
3. Connect to RDS: Once the database status is "Available," you can find its Endpoint in the "Connectivity & security" tab. Use a database client (e.g., MySQL Workbench) to connect.

B. Amazon DynamoDB - GUI Usage:

A fast and flexible NoSQL database service.

1. Navigate to DynamoDB:

   AWS Management Console > Search for "DynamoDB" > Select DynamoDB under Services

2. Create Table:
   • Click **Create table**.
   • Table name: (e.g., `MyProducts`).
   • Partition key: (e.g., `ProductId`, Type `String`).
   • Sort key: (e.g., `Category`, Type `String` - optional, but good for range queries).
   • (Optional) Disable default settings to adjust capacity units, Auto Scaling.
   • Click **Create table**.
3. Add Items: In the table, go to the "Items" tab and click "Create item" to manually add data.

C. Amazon Aurora - GUI Usage:

A MySQL and PostgreSQL-compatible relational database built for the cloud, combining the performance and availability of traditional enterprise databases with the simplicity and cost-effectiveness of open-source databases.

1. Navigate to RDS: (Aurora is an engine option within RDS).

   AWS Management Console > RDS > Databases

2. Create Database:
   • Click **Create database**.
   • Engine options: Choose `Amazon Aurora`.
   • Select an Edition (MySQL or PostgreSQL compatible).
   • Follow the wizard similar to RDS, configuring instance size, storage, and connectivity.
   • Click **Create database**.

D. Amazon Redshift - GUI Usage:

A fast, fully managed, petabyte-scale cloud data warehouse service.

1. Navigate to Redshift:

   AWS Management Console > Search for "Redshift" > Select Amazon Redshift under Services

2. Create Cluster:
   • Click **Create cluster**.
   • Configure cluster identifier, node type, database configuration (admin user/password).
   • Configure network settings (VPC, security group).
   • Click **Create cluster**.

8. Security, Identity, & Compliance

These services help you protect your AWS resources and data.

A. AWS IAM (Identity and Access Management) - GUI Usage:

Manages access to AWS services and resources securely.

1. Navigate to IAM:

   AWS Management Console > Search for "IAM" > Select IAM under Services

2. Create an IAM User:
   • In the left navigation pane, click **Users** > **Create user**.
   • User name: (e.g., `my-dev-user`). Click **Next**.
   • Set permissions:
     • Select "Attach policies directly".
     • Search for a policy (e.g., `AmazonS3ReadOnlyAccess`). Check the box.
     • (For initial learning, you might attach `AdministratorAccess` for broad access, but limit in production).
   • Click **Next** > **Create user**.
   • Access Keys (for CLI/SDK): After creating the user, click on the user name, go to **Security credentials** tab > **Create access key**. Follow prompts to download the `.csv` file with Access Key ID and Secret Access Key (store securely!).
3. Create an IAM Role:
   • In the left navigation pane, click **Roles** > **Create role**.
   • Choose the entity that will assume this role (e.g., `AWS service` > `EC2`). Click **Next**.
   • Attach permission policies (e.g., `AmazonS3ReadOnlyAccess`). Click **Next**.
   • Add tags (optional) > Click **Next**.
   • Provide a **Role name** (e.g., `EC2S3ReadRole`) and **Description**.
   • Click **Create role**.

B. Amazon GuardDuty - GUI Usage:

A threat detection service that continuously monitors for malicious activity and unauthorized behavior.

1. Navigate to GuardDuty:

   AWS Management Console > Search for "GuardDuty" > Select GuardDuty under Services

2. Enable GuardDuty:
   • On the GuardDuty welcome page, click **Get started**.
   • On the Welcome to GuardDuty page, click **Enable GuardDuty**.
   • GuardDuty will automatically begin monitoring your AWS account.
3. Generate Sample Findings (Optional):
   • In the GuardDuty console, go to **Settings** > **Generate sample findings**.
   • This will populate your findings list with sample alerts for various threat types.

C. AWS Security Hub - GUI Usage:

Provides a comprehensive view of your security alerts and security posture across your AWS accounts.

1. Navigate to Security Hub:

   AWS Management Console > Search for "Security Hub" > Select Security Hub under Services

2. Enable Security Hub:
   • Click **Go to Security Hub**.
   • Choose your regions and standards (e.g., AWS Foundational Security Best Practices).
   • Click **Enable Security Hub**.

D. AWS WAF (Web Application Firewall) - GUI Usage:

Helps protect your web applications or APIs against common web exploits that may affect availability, compromise security, or consume excessive resources.

1. Navigate to WAF & Shield:

   AWS Management Console > Search for "WAF" > Select WAF & Shield under Services

2. Create Web ACL:
   • Click **Web ACLs** > **Create web ACL**.
   • **Region:** Select the region where your resources (ALB, API Gateway, CloudFront) are deployed.
   • Associate with a **resource** (e.g., an Application Load Balancer).
   • Add **rules** (e.g., SQL injection, XSS rules) to protect against specific attacks.
   • Click **Create web ACL**.

9. Management, Governance, & Serverless

Services to help you manage, monitor, and govern your AWS environment efficiently.

A. Amazon CloudWatch - GUI Usage:

Monitors your AWS resources and the applications you run on AWS in real-time.

1. Navigate to CloudWatch:

   AWS Management Console > Search for "CloudWatch" > Select CloudWatch under Services

2. Explore Metrics:
   • In the left navigation pane, click **Metrics** > **All metrics**.
   • Explore metrics by AWS service (e.g., `EC2 > Per-Instance Metrics` to see CPU Utilization, Network In/Out).
3. Create Alarms:
   • In the left navigation pane, click **Alarms** > **Create alarm**.
   • Select a metric (e.g., `EC2 > CPU Utilization` for a specific instance).
   • Define a **Threshold type** (e.g., `Static`) and a **Threshold value** (e.g., `> 80%`).
   • Configure **Actions** (e.g., `Send a notification to an SNS topic`).
   • Click **Create alarm**.
4. View Logs:
   • In the left navigation pane, click **Logs** > **Log groups**.
   • Explore log groups created by Lambda, EC2 (with CloudWatch agent), etc.

B. AWS CloudFormation - GUI Usage:

Automates the creation and management of AWS resources using templates (Infrastructure as Code).

1. Navigate to CloudFormation:

   AWS Management Console > Search for "CloudFormation" > Select CloudFormation under Services

2. Create Stack:
   • Click **Create stack** > **With new resources (standard)**.
   • Prepare template: Select "Template is ready".
   • Template source: Choose "Upload a template file" and upload your `my-web-app.yaml` (from CLI tutorial) or `simple-vm-template.json` (from GCP CLI tutorial for illustration).
   • Click **Next**.
   • Stack name: (e.g., `MyWebServerStackGUI`).
   • Parameters: Provide values for any parameters defined in your template (e.g., `adminPassword` for a VM).
   • Click **Next**.
   • Configure stack options: (Optional, e.g., tags, rollback configurations). Click **Next**.
   • Review: Review details. Check "I acknowledge that AWS CloudFormation might create IAM resources."
   • Click **Submit**.
3. Monitor & Delete: The CloudFormation console will show the status of your stack creation. To delete the stack and all its resources, select the stack and click **Delete**.

C. AWS Systems Manager (SSM) - GUI Usage:

Provides visibility and control over your AWS infrastructure.

1. Navigate to Systems Manager:

   AWS Management Console > Search for "Systems Manager" > Select Systems Manager under Services

2. Explore Capabilities:
   • Session Manager: Get shell access to EC2 instances without opening SSH ports.
   • Patch Manager: Automate patching of OS and applications.
   • Run Command: Execute commands on multiple instances simultaneously.
   • Fleet Manager: Centrally manage your instances.

10. Analytics & Machine Learning

AWS offers a wide array of services for data analytics and AI/ML.

A. Amazon Athena - GUI Usage:

An interactive query service that makes it easy to analyze data directly in Amazon S3 using standard SQL.

1. Navigate to Athena:

   AWS Management Console > Search for "Athena" > Select Athena under Services

2. Set up Query Result Location:
   • If it's your first time, you'll be prompted to set up a query result location in S3.
   • Go to **Settings** > **Manage settings** > **Browse S3** to select/create a bucket.
3. Create Table from S3 Data:
   • In the left pane, click the **+** next to "Tables" > **Create table from S3 bucket data**.
   • Follow the wizard to define:
     • **Database** (create new or select existing).
     • **Table name**.
     • **S3 input and output location**.
     • **Data format** (e.g., CSV, JSON, Parquet).
     • Define **columns** and their **data types**.
   • Click **Create table**.
4. Run Queries: Use the query editor to write SQL queries against your S3 data.

B. Amazon Kinesis - GUI Usage:

Collects, processes, and analyzes real-time streaming data.

1. Navigate to Kinesis:

   AWS Management Console > Search for "Kinesis" > Select Kinesis under Services

2. Create Kinesis Data Stream:
   • Click **Create data stream**.
   • Provide a **Data stream name** and number of **shards**.
   • Click **Create data stream**.

C. AWS Glue - GUI Usage:

A serverless data integration service that makes it easy to discover, prepare, and combine data for analytics, machine learning, and application development.

1. Navigate to Glue:

   AWS Management Console > Search for "Glue" > Select AWS Glue under Services

2. Create Crawler:
   • In the left pane, click **Crawlers** > **Add crawler**.
   • Configure crawler name, data source (e.g., S3 path), IAM role.
   • This will create a "Data Catalog" (metadata repository) of your data.
3. Create ETL Job:
   • Go to **ETL jobs** > **Add job**.
   • Define source and target data, transformations (e.g., join, filter).

D. Amazon SageMaker - GUI Usage:

A fully managed service that helps developers and data scientists build, train, and deploy machine learning models quickly.

1. Navigate to SageMaker:

   AWS Management Console > Search for "SageMaker" > Select Amazon SageMaker under Services

2. Create Notebook Instance:
   • In the left pane, click **Notebook** > **Notebook instances**.
   • Click **Create notebook instance**.
   • **Notebook instance name:** (e.g., `my-ml-notebook`).
   • **Notebook instance type:** (e.g., `ml.t2.medium` for Free Tier if available).
   • Platform identifier: (e.g., `conda-python3`).
   • IAM role: Select "Create a new role" or choose an existing one with SageMaker permissions.
   • Click **Create notebook instance**.
3. Open Jupyter: Once the status is "InService", click **Open Jupyter** or **Open JupyterLab** to start coding in a notebook.

11. Developer Tools

Services for continuous integration and continuous delivery (CI/CD).

A. AWS CodeCommit - GUI Usage:

A fully-managed source control service that hosts secure Git-based repositories.

1. Navigate to CodeCommit:

   AWS Management Console > Search for "CodeCommit" > Select CodeCommit under Services

2. Create Repository:
   • Click **Create repository**.
   • Repository name: (e.g., `my-app-repo`).
   • Click **Create**.
3. Connect: Follow the instructions provided to set up Git credentials (HTTPS or SSH) and clone/push your code.

B. AWS CodePipeline - GUI Usage:

A continuous delivery service that automates your release pipelines.

1. Navigate to CodePipeline:

   AWS Management Console > Search for "CodePipeline" > Select CodePipeline under Services

2. Create Pipeline:
   • Click **Create pipeline**.
   • Pipeline name: (e.g., `my-app-pipeline`).
   • Choose a **Service role**.
   • Source stage: Choose **AWS CodeCommit**, select your repository and branch.
   • Build stage: Choose **AWS CodeBuild** (you'd need to create a CodeBuild project first).
   • Deploy stage: Choose **AWS CodeDeploy** or **Amazon S3** (for static website deployment).
   • Click **Create pipeline**.

C. AWS CodeBuild - GUI Usage:

A fully managed continuous integration service that compiles source code, runs tests, and produces software packages.

1. Navigate to CodeBuild:

   AWS Management Console > Search for "CodeBuild" > Select CodeBuild under Services

2. Create Build Project:
   • Click **Create build project**.
   • Project name: (e.g., `my-app-build`).
   • Source: Select your source provider (CodeCommit, S3, GitHub).
   • Environment: Choose Managed image, Operating system, Runtime (e.g., Node.js, Python).
   • Buildspec: Define your build commands (e.g., `npm install`, `npm test`, `npm run build`) in a `buildspec.yml` file in your repository, or use the editor.
   • Click **Create build project**.

D. AWS CodeDeploy - GUI Usage:

Automates software deployments to a variety of compute services.

1. Navigate to CodeDeploy:

   AWS Management Console > Search for "CodeDeploy" > Select CodeDeploy under Services

2. Create Application & Deployment Group:
   • Click **Applications** > **Create application**. Provide a name.
   • Click on the application > **Create deployment group**.
   • Configure deployment type (EC2/On-premises, ECS, Lambda), deployment strategy.

12. Cost Management

Understanding and controlling your AWS spending is critical.

1. AWS Free Tier: As mentioned, leverage this for learning.
2. AWS Cost Explorer:

   AWS Management Console > Search for "Cost Explorer" > Select Cost Explorer under Services

   • Visualize, understand, and manage your AWS costs and usage over time. Apply filters, group by service, region, tags.
3. Budgets:

   AWS Management Console > Search for "Budgets" > Select AWS Budgets under Services

   • Click **Create budget**.
   • Choose budget type (e.g., `Cost budget`). Define your budget amount and period.
   • Configure **Alerts** to notify you when actual or forecasted costs exceed thresholds.
4. Savings Plans & Reserved Instances (RIs):

   AWS Management Console > EC2 > Savings Plans / Reserved Instances

   • Explore options to commit to a certain amount of compute usage over 1 or 3 years for significant discounts.
5. Tagging: Apply tags (key-value pairs) to your resources to organize costs by project, department, etc. You can apply tags when creating most resources in the console.
6. Right-Sizing: Continuously monitor resource utilization (e.g., in CloudWatch) and choose the smallest instance type or storage class that meets your needs.

13. Best Practices (Well-Architected Framework)

The AWS Well-Architected Framework provides guidance for designing and operating reliable, secure, efficient, and cost-effective systems in the cloud. It's built around six pillars:

• Operational Excellence: Run and monitor systems, and continuously improve processes and procedures.
• Security: Protect information, systems, and assets while delivering business value through risk assessments and mitigation strategies.
• Reliability: Ensure your workload performs its intended function correctly and consistently when it's expected to.
• Performance Efficiency: Use computing resources efficiently to meet system requirements, and maintain that efficiency as demand changes and technologies evolve.
• Cost Optimization: Avoid unnecessary costs.
• Sustainability: Minimize the environmental impacts of running cloud workloads.