Important notice: To keep this article beginner friendly, I will not be listing every product/service in each category, but the most used ones. AWS has a lot of products and sub-products you can dive in at your own pace.

Compute Services
AWS's compute offerings are the backbone of its platform, helping developers run application code and manage servers effortlessly. Here are two key services, please keep in mind these are not all the compute services but two of the most used:

AWS Lambda
A serverless service where you can run your code without worrying about servers
You only pay for the compute time you use
Amazon EC2
Provides virtual servers (instances) that you can configure to host your applications
It's flexible and straightforward to use
Storage and Content Delivery
AWS provides a wide range of storage solutions for different application needs. Which are typically split into three types: object, block, file storage:

Amazon S3
A reliable, scalable object storage service
Store and retrieve large amounts of data, accessible from anywhere
Amazon EBS
A block storage service designed for use with Amazon EC2
Ideal for workloads requiring consistent, low-latency performance
Amazon EFS
A scalable file storage solution
Allows multiple instances to access data simultaneously
Great for shared storage scenarios
Database Services
Databases are at the heart of most applications. AWS makes database management easy with these popular services:

Amazon RDS
A managed relational database service
Supports multiple engines: MySQL, PostgreSQL, MariaDB, Oracle, and SQL Server
Simplifies tasks like setting up, running, and scaling databases
Amazon DynamoDB
A NoSQL database designed for fast, millisecond-level performance
Built-in security, backup, and restore capabilities
Scales automatically based on demand
Amazon DocumentDB
A managed NoSQL document database service
MongoDB compatible
Designed for scalable, high-performance workloads
Amazon Aurora
A fully managed relational database engine
Combines high-end commercial database performance with open-source simplicity
Compatible with MySQL and PostgreSQL
Amazon Redshift
A managed data warehouse service
Designed for big data analytics
Run complex queries across petabytes of data quickly and securely
Networking and Security
Strong networking and security are crucial for cloud applications. AWS provides tools to integrate and safeguard your applications effectively:

Amazon VPC
Create a private network within AWS
Define subnets, route tables, and gateways
Control network traffic effectively
AWS IAM
Identity and Access Management
Securely control access to AWS resources
Define user permissions and roles
AWS Direct Connect
Provides dedicated network connections
Connect on-premises data center to AWS
Improved bandwidth and security
AWS Shield
Managed DDoS protection service
Safeguards AWS applications from malicious attacks
AWS WAF
Web application firewall
Protects applications from common web exploits
Customizable security rules
Amazon GuardDuty
Continuous threat detection service
Monitors for malicious activity
Identifies unauthorized behavior
AWS Secrets Manager
Securely store and manage sensitive information
Handle API keys, passwords, and credentials
Automated secrets rotation
Conclusion: Getting Started with AWS
AWS has the tools needed to innovate and scale quickly, provided that you have the knowledge and skills to use them. By getting a solid understanding of core services like compute, storage, databases, and networking, you'll be well-equipped to dive deeper into the more situational products and the more niche ones.

As the title suggests this is just a beginner's preview—there's a lot more to explore and dive into as you advance. Take some time to experiment with these services in your next project.

Amazon Web Services (AWS) is a cloud platform offering a vast range of tools to help developers build, deploy, and scale applications faster and more cost-effectively. Whether you're creating web apps, mobile solutions, or any cloud-based project, getting familiar with AWS's core services is a must if cloud is a topic of interest to you.

AWS for beginners : Essential Services to know

Why Use S3 for Hosting?
Instead of using an EC2 instance, we will deploy a static site on an S3 bucket. This is a cost-effective and scalable way to host static assets.

Prerequisites
An AWS account
An existing app or website
AWS CLI installed and configured
Step 1: Create an S3 Bucket
Amazon S3 is a versatile object storage service that can be used for hosting static websites. To set it up:

Log in to your AWS account.
Navigate to S3 and click Create bucket.
Enter a unique bucket name and select a region.
Bucket names must be globally unique, so if you get an error, try adding numbers to the name.
Disable the Block all public access option to make your site publicly accessible.
(For security, use IAM roles in production, but for static hosting, public access is required.)
Click Create to finalize.
Step 2: Upload Build Files to S3 Bucket
Once your bucket is ready, upload your app’s files:

Open your terminal and navigate to your project’s build folder.
Run the following command to sync your files with S3:
aws s3 sync build/ s3://<your-bucket-name>/
Replace <your-bucket-name> with your actual S3 bucket name.
Step 3: Configure S3 Bucket for Static Hosting
Enable static website hosting for your bucket:

Open your bucket in the S3 console and go to the Properties tab.
In the Static website hosting section, enable hosting.
Set index.html as the index document and optionally set error.html as the error document.
Save the changes.
Step 4: Associate a Domain Name (Optional)
To make your app accessible via a custom domain:

Use AWS Route 53 or another DNS provider to register a domain name.
Configure the domain to point to your S3 bucket.
Step 5: Enable CloudFront CDN (Optional)
Improve performance by using AWS CloudFront for content delivery:

In the AWS Management Console, navigate to CloudFront and create a new distribution.
Set your S3 bucket as the origin.
Configure caching and security settings as needed.
Conclusion
Congratulations! Your static website or app is now deployed on AWS using S3 for hosting. This setup ensures your app is fast, reliable, and accessible worldwide. Optional steps like adding a custom domain or enabling a CDN can further enhance the user experience.

Deploying a website or app on Amazon Web Services (AWS) provides a reliable and scalable platform for your application. With AWS’s global infrastructure, your app can perform optimally and remain accessible to users worldwide. This guide walks you through the steps to deploy a static website or app on AWS seamlessly.

How to Deploy a Static Website or App on AWS

Prerequisites
AWS free-tier account (or another cloud provider with minor adjustments)
GitHub repository (front-end or back-end code)
Basic familiarity with Linux commands and Bash scripting
Server Setup: EC2 Instance
For this article, an AWS EC2 instance will be used to host the Jenkins server and run Docker containers. However, the steps are applicable to other cloud providers or even physical servers.

Instead of manually provisioning servers via the AWS UI, Terraform can be used. Example Terraform configuration is available here: [Terraform Code - GitHub]

Setting Up GitHub SSH Key
To automate code fetching and building:

Connect to the EC2 instance and generate an SSH key:
ssh-keygen
Display the public key:
cat /home/ubuntu/.ssh/id_rsa.pub
Copy and add the public key to GitHub Settings > SSH and GPG Keys as an authentication key.
Jenkins Server Configuration
After launching the EC2 instance, install the required tools:

Jenkins (on Ubuntu 22.04)
Git, Node.js, and npm
Docker
Note: Pre-configured installation scripts are available here: [Automated Tools Install Script]

Accessing Jenkins
Ensure port 8080 is open, then access Jenkins via:

http://instance.public_ip:8080
Set up an admin user, install recommended plugins, and proceed to the dashboard.

Configuring a Jenkins Pipeline
Create a Freestyle Jenkins Pipeline and add the GitHub repository.
Set Git credentials using the SSH private key:
cat /home/ubuntu/.ssh/id_rsa
Go to Jenkins Dashboard > Manage Jenkins > Credentials, and add an SSH private key.
Automating Docker Build and Deployment
Instead of manually running Docker commands, automate the process within Jenkins:

#!/bin/bash
docker rm -f $(docker ps -aq)
docker build -t yourappname .
docker run -d --name yourappname -p PORT:PORT yourappname:latest
echo "Built and ran project on port ...."
Run the pipeline and verify that the application is accessible at:

http://instance.public_ip:PORT
Setting Up GitHub Webhook
To fully automate deployment:

Install the GitHub Integration Plugin in Jenkins.
Enable GitHub hook trigger for GIT SCM polling in the pipeline configuration.
Add a webhook in GitHub Repo Settings > Webhooks with the following payload URL:
http://instance.public_ip:8080/github-webhook
Save the webhook and push changes to the repository to test automation.
Conclusion
By implementing this CI/CD workflow, code changes are automatically fetched, built into Docker images, and deployed on an EC2 instance. This ensures efficient, reliable, and automated software delivery, improving both development speed and operational stability.

Continuous Integration and Continuous Deployment (CI/CD) workflows have transformed the way we write and ship code. This guide explores how to configure a Jenkins server to fetch the latest code changes from a Git repository using webhooks, build Docker images, and run application containers on an AWS EC2 instance.

CI/CD Workflow with Jenkins, Docker, and AWS EC2

1. Provisioning AWS EC2 Instance
Introduction:
Provisioning an AWS EC2 instance is the first step towards building a scalable and reliable infrastructure for your applications. We explore the AWS Management Console, guiding you through the instance configuration, security group setup, and IAM role assignment.

Key Considerations:
Selecting the appropriate region.
Configuring instance details such as type, storage, and security groups.
Ensuring IAM role permissions align with the project's requirements.
Best Practices:
Utilizing tags for better instance management.
Enabling CloudWatch for monitoring and logging.
2. SSH and Jenkins Setup
Introduction:
Securing access to the EC2 instance is achieved through SSH. We delve into the process of generating an SSH key pair, securely storing the private key, and connecting to the instance. The article also covers updating system packages, installing Java, and initiating the setup of Jenkins.

Implementation Details:
Generating and managing SSH key pairs.
Updating system packages and installing Java.
Setting up Jenkins by adding the Jenkins repository and starting the Jenkins service.
Security Measures:
Best practices for securing SSH access.
Configuring Jenkins to run securely.
3. Jenkins Configuration and Plugin Setup
Introduction:
Configuring Jenkins is a pivotal step in the automation journey. We guide you through unlocking Jenkins, installing essential plugins, and configuring global environment variables for secure credential storage.

Plugin Highlights:
Docker Integration for seamless containerization.
SonarQube integration for static code analysis.
Trivy and OWASP plugins for security checks.
Setting up environment variables for secure credential storage.
Configuration Best Practices:
Implementing Role-Based Access Control (RBAC) in Jenkins.
Ensuring secure storage of credentials.
4. Building the Pipeline
Introduction:
The heart of our CI/CD process is the Jenkins pipeline. This section details the creation of a Jenkinsfile, defining the pipeline stages. Initial stages focus on preparing the workspace and installing necessary tools, ensuring a clean environment for subsequent operations.

Pipeline Components:
Stages for workspace preparation and tool installation.
Utilizing the declarative syntax for pipeline simplicity.
Integrating conditional steps for flexibility.
Testing and Validation:
Implementing unit tests within the pipeline.
Using the pipeline visualizer for a clear overview.
5. Application Source Code Checkout
Introduction:
Using Git integration, the pipeline checks out the latest source code from the main branch of our React side project. This step ensures that the pipeline operates on the most up-to-date codebase.

Version Control Integration:
Configuring Git integration in Jenkins.
Defining repository and branch details in the pipeline.
Ensuring Code Consistency:
Handling conflicts and merge strategies within the pipeline.
6. Static Code Analysis with SonarQube
Introduction:
SonarQube becomes an integral part of our CI/CD process, offering insights into code quality, security, and maintainability. We define project-specific settings in SonarQube, ensuring analysis aligns with the project's requirements.

SonarQube Integration:
Configuring SonarQube in Jenkins.
Defining analysis parameters in the Jenkinsfile.
Interpreting Analysis Results:
Understanding SonarQube metrics and reports.
Implementing quality gates for fail-fast scenarios.
7. Validation and Bug Prevention
Introduction:
In a proactive approach to bug prevention, the pipeline is configured to exit if SonarQube identifies critical issues. This validation step ensures that only code meeting predefined quality criteria progresses through the pipeline.

Quality Control Measures:
Setting up quality gates for specific criteria.
Configuring pipeline notifications on quality gate failure.
Ensuring Reliable Builds:
The role of static analysis in bug prevention.
Balancing between strict and lenient validation.
8. Dependency Installation Post SonarQube Clean Check
Introduction:
Post SonarQube checks, the pipeline proceeds to install application dependencies. This step ensures that the application has all the required dependencies in a clean and validated environment.

Dependency Management:
Utilizing package managers for language-specific dependencies.
Running dependency checks for security and version compliance.
Pipeline Efficiency:
Parallelizing dependency installation for faster builds.
Caching dependencies for subsequent builds.
9. Thorough Security Checks with OWASP
Introduction:
The pipeline integrates OWASP Dependency-Check to conduct thorough security checks. This tool identifies and reports known vulnerabilities in project dependencies, contributing to a more secure application.

OWASP Integration:
Configuring OWASP Dependency-Check in Jenkins.
Setting up policies for vulnerability severity levels.
Security Best Practices:
Regularly updating dependency databases.
Establishing a schedule for vulnerability scans.
10. Aqua Trivy Scan
Introduction:
Aqua Trivy is employed to perform a comprehensive vulnerability scan on the application's file system. The results of this scan provide detailed information about potential vulnerabilities, allowing for proactive mitigation.

Trivy Integration:
Configuring Trivy in Jenkins.
Analyzing scan results and determining severity levels.
Mitigation Strategies:
Implementing fixes for identified vulnerabilities.
Establishing a process for continuous monitoring.
11. Docker Image Management
Introduction:
The pipeline automates the tagging, building, and pushing of Docker images to a Docker registry. This streamlined process ensures consistency in image versions and facilitates easy deployment across environments.

Docker Image Lifecycle:
Tagging images for version control.
Utilizing multi-stage builds for efficient image creation.
Registry Integration:
Configuring Jenkins to interact with Docker registries.
Managing credentials securely in Jenkins.
12. Post-Build Security: Docker Image Scanning with Trivy
Introduction:
Post-build, the pipeline continues its commitment to security by scanning Docker images with Trivy. This post-build scan helps identify vulnerabilities introduced during the image creation process.

Post-Build Security Measures:
Automating image scans as a post-build step.
Integrating scan results into Jenkins reports.
Regulatory Compliance:
Aligning image scans with industry security standards.
Configuring policies for acceptable vulnerability levels.
13. Containerized Application Deployment
Introduction:
The final stages of the pipeline focus on deploying the application. The Docker image, now verified and secure, is published to a container, making the application ready for use.

Container Orchestration:
Integrating with container orchestration tools.
Configuring deployment strategies for different environments.
Rollback Strategies:
Implementing automated rollback on deployment failure.
Monitoring deployment health and performance.
14. Reporting via SMTP Server
Introduction:
To keep stakeholders informed, we configure an SMTP server to receive comprehensive reports. This step involves setting up Jenkins email notifications to send detailed reports on pipeline completion.

SMTP Configuration:
Configuring SMTP server details in Jenkins.
Defining email templates for different pipeline outcomes.
Stakeholder Communication:
Ensuring reports are concise and informative.
Establishing communication channels for critical issues.
This article is the overview of each step that I will expand in detail in my upcoming in-depth guide for this workflow. Each section offers insights, implementation steps, and best practices to ensure a smooth and reliable automation process.

In the ever-evolving landscape of software development, the need for efficient and secure Continuous Integration and Continuous Deployment (CI/CD) pipelines is paramount. This article is a brief overview of the steps involved and takes you through the process of provisioning an AWS EC2 instance, configuring Jenkins, and establishing a robust CI/CD pipeline for a React side project.

Overview of a ful cicd setup in Cloud, AWS EC2, Jenkins

Prerequisites
An AWS account, AWS CLI, and configured credentials (aws configure)
Terraform installed in your local environment
Terraform Code - main.tf File
Provider Configuration
We start by defining the required AWS provider and setting the region:

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
    }
  }
}

provider "aws" {
  region = "Enter-your-region-here"
}
Setup and Configure the EC2 Instance
Define the AWS EC2 instance with configurations such as AMI, instance type, and key name:

resource "aws_instance" "your_instance_name" {
  ami                    = "ami-0505148b3591e4c07" # Ubuntu AMI ID
  instance_type          = "t2.micro"
  key_name               = var.ssh_key_name
  vpc_security_group_ids = [aws_security_group.sg.id]

  tags = {
    Name = var.prefix
  }

  user_data = data.template_file.userdata.rendered

  connection {
    type        = "ssh"
    user        = "ec2-user"
    private_key = file(var.ssh_private_key)
    host        = self.public_ip
  }

  provisioner "file" {
    source      = "~/setup.sh"
    destination = "/tmp/setup.sh"
  }

  provisioner "remote-exec" {
    inline = [
      "chmod +x /tmp/setup.sh",
      "sudo /tmp/setup.sh",
    ]
  }
}
Creating a Security Group
A security group is created to manage inbound and outbound traffic:

locals {
  ingress_ports = [22, 8080, 9000, 3000, 3306, 5137, 443]
}

resource "aws_security_group" "sg" {
  name = "${var.prefix}-sg"

  dynamic "ingress" {
    for_each = local.ingress_ports
    iterator = port
    content {
      from_port   = port.value
      protocol    = "tcp"
      to_port     = port.value
      cidr_blocks = ["0.0.0.0/0"]
    }
  }

  egress {
    from_port   = 0
    protocol    = -1
    to_port     = 0
    cidr_blocks = ["0.0.0.0/0"]
  }
}
Optional: Running a Startup Script
data "template_file" "userdata" {
  template = file("${abspath(path.module)}/setup.sh")
}
variables.tf File
Always follow security best practices when handling credentials. Here’s an example of variable setup:

variable "prefix" {
  default = "your-instance-name"
}

variable "ssh_key_name" {
  default = "your-keypair-name"
}

variable "ssh_private_key" {
  description = "Path to the SSH private key file"
  type        = string
  default     = "/path/to/keypair.pem"
}
outputs.tf File
Define outputs to display useful connection details after provisioning:

output "SSH_Command" {
  value = "ssh -i ${var.ssh_private_key} ec2-user@${aws_instance.your_instance_name.public_ip}"
}
Running Terraform Commands
terraform init
terraform plan -out main.plan
terraform apply "main.plan"

# Destroy resources when finished
terraform destroy
Conclusion
Terraform makes setting up AWS instances a breeze. No more manual configurations—let Terraform handle the heavy lifting, so you can focus on building your applications.

Further Learning:
Terraform Documentation
AWS Provider - Terraform
#devops #aws #iac #terraform

As part of my journey embracing DevOps culture and tools, Terraform and its companions in the realm of Infrastructure as Code (IaC) naturally became integral waypoints on my roadmap. Embracing the principles of DevOps involves not just a mindset shift but also a strategic adoption of tools that enhance efficiency, scalability, and reproducibility.

Let's dive in and deploy some resources to AWS using Terraform.



Discover Insights And Tips
For Your Future.

Free Create

Resume

AWS for beginners : Essential Services to know

How to Deploy a Static Website or App on AWS

CI/CD Workflow with Jenkins, Docker, and AWS EC2

All Articles

AWS for beginners : Essential Services to know

How to Deploy a Static Website or App on AWS

CI/CD Workflow with Jenkins, Docker, and AWS EC2

Overview of a ful cicd setup in Cloud, AWS EC2, Jenkins

Deploying AWS Resources with Terraform

Discover Insights And Tips For Your Future.

Free Create

Resume

AWS for beginners : Essential Services to know

How to Deploy a Static Website or App on AWS

CI/CD Workflow with Jenkins, Docker, and AWS EC2

All Articles

AWS for beginners : Essential Services to know

How to Deploy a Static Website or App on AWS

CI/CD Workflow with Jenkins, Docker, and AWS EC2

Overview of a ful cicd setup in Cloud, AWS EC2, Jenkins

Deploying AWS Resources with Terraform

Discover Insights And Tips
For Your Future.