Forem: Usman Ahmad

Difference between AWS VPC Peering and AWS Transit Gateway

Usman Ahmad — Thu, 13 Apr 2023 07:07:50 +0000

AWS VPC Peering and AWS Transit Gateway are two different ways to connect multiple Virtual Private Clouds (VPCs) within an AWS environment.

VPC Peering allows you to connect two VPCs within the same AWS account or across different AWS accounts, using private IP addresses. It provides a direct network connection between the VPCs, allowing them to communicate with each other securely and efficiently. VPC peering is suitable for scenarios where you need to connect a few VPCs and have a simple network topology.

On the other hand,

AWS Transit Gateway is a fully managed service that provides a centralized hub for connecting multiple VPCs and on-premises networks. It simplifies network management by allowing you to create a single transit gateway and attach multiple VPCs and VPN connections to it. This eliminates the need for creating multiple VPC peering connections, which can be difficult to manage and scale as the number of VPCs grows.

In summary, AWS VPC peering is suitable for connecting a few VPCs with a simple network topology, while AWS Transit Gateway is designed for managing complex network topologies with multiple VPCs and on-premises networks.

Modify the AWS RDS Instance size using Lambda Function

Usman Ahmad — Thu, 30 Mar 2023 06:20:48 +0000

This article gives you an overview of the AWS Lambda function to modify the RDS instance class using Python language in Lambda function without stopping the RDS instance.

Let’s follow this article to modify RDS instance using Lambda function.

Steps to create AWS Lambda Function for AWS RDS Instance class

we use the following steps to configure a lambda function.

Step1: Create an IAM Policy

The first step is to create IAM policy to gain access to RDS actions and AWS CloudWatch log events.

Navigate to IAM in the services and click on Policies => Create Policy.

Step2: Create an IAM Role and attach “Lambda_RDS_modification_policy”

In this step, we are creating an IAM role and attach the policy created in the previous step. Click on Roles -> Create Role:

Step3: Create an AWS Lambda Function

Now we will create AWS Lambda function to modify RDS instance class. First you have to select “Author from scratch” -> Function Name -> Runtime (Python3.7 or 3.8) -> Existing Role “RDS_Lambda_Role”

Add inline policy in existing IAM Role

Now, open a new tab for the IAM role and edit the existing Role RDS_Lambda. In the summary page, click on Add Inline Policy

In the Inline policy editor, paste the following JSON. Here, you note that we used the AWS lambda ARN in the resource section. You can copy ARN for your existing lambda ARN.

Lambda ARN follows the format: arn:aws:lambda:Region-AWS Account:function:lambda_function_Name

{   
   "Version": "2012-10-17",
   "Statement": [
{
      "Effect": "Allow",
      "Action": "lambda:GetFunctionConfiguration",
      "Resource": "arn:aws:lambda:us-east-1:11111111111:function:RDSStartFunction"
      }
   ]
}

Step4: Function Code: Scroll down and paste the Python code inside the editor. You need to select appropriate language in the run time. I go with the latest version Python 3.8

Python Code:

Here we are using 2 environment variables:

DBinstance
DBinstanceClass

import sys
import botocore
import boto3
import json
from botocore.exceptions import ClientError
def lambda_handler(event, context):
    rds = boto3.client('rds')
    lambdaFunc = boto3.client('lambda')
    print ('Trying to get Environment variable')
    try:
        funcResponse = lambdaFunc.get_function_configuration(
            FunctionName='RDS_Instance_Modification_Function'
       )
        DBinstance = funcResponse['Environment']['Variables']['DBInstanceName']
        DBinstanceClass = funcResponse['Environment']['Variables']['DBinstanceClass']

        print (f'Starting RDS service for DBInstance : {DBinstance}')
        print (f'RDS instance class : {DBinstanceClass}')


        response = rds.modify_db_instance(DBInstanceIdentifier=DBinstance, DBInstanceClass=DBinstanceClass, ApplyImmediately=True)

        print (f'Success :: {response} ') 
        return json.dumps(dict(abc=123))
    except ClientError as e:
return json.dumps(dict(error=str(e)))

    return json.dumps(dict(abc=12345))

Creating Environment Variables:

Step5: I already created one testdb RDS instance for the testing

Step6: Now we will test the Lambda Function

Click on the “Test” button

First time when you run it and as you already entered the “db.t2.micro” so the result will be like:

But now I will change the “DBinstanceClass” to “db.t2.small” so this time it will successfully modify the AWS RDS instance “testdb” class to “db.t2.small”

Now you will get the following logs after running the lambda function

Here you will see that the RDS instance is now “modifying” status. It will take some time to show you the result as this instance size will be change from “db.t2.micro” to “db.t2.small”

Final result: after modification you will see that now the instance size is “db.t2.small” and status is now “Available”

How to use Kubernetes Secret to pull private Docker Images from DockerHub

Usman Ahmad — Mon, 27 Mar 2023 09:26:33 +0000

In this article, you will learn how we pull the private docker image from DockerHub using Kubernetes Secret and create a Kubernetes Pod from the docker private image.

Docker Hub:

Docker Hub is a hosted repository service provided by Docker for finding and sharing container images with your team. Key features include Private Repositories: Push and pull container images. Automated Builds: Automatically build container images from GitHub and Bitbucket and push them to Docker Hub.

Kubernetes Secrets:

A Secret is an object that contains a small amount of sensitive data such as a password, a token, or a key. Such information might otherwise be put in a Pod specification or in a container image. Using a Secret means that you don’t need to include confidential data in your application code.

Example:

To use a secret to pull a private image from a container registry, you can create a “imagePullSecrets” field in your deployment or pod YAML file. Here’s an example:

Step1: Create a secret

kubectl create secret docker-registry my-registry-secret \
— docker-username=DOCKER_USER \
— docker-password=DOCKER_PASSWORD \
— docker-email=DOCKER_EMAIL

Replace the DOCKER_REGISTRY_SERVER, DOCKER_USER, DOCKER_PASSWORD, and DOCKER_EMAIL with your container registry server address, username, password, and email respectively.

Step2: My Dockerhub account, where I have my private docker image

Step3: Create a deployment file with “imagePullSecrets”

Modify your deployment or pod YAML file to include the imagePullSecrets field:

In this example, we added the imagePullSecrets field to the deployment YAML file, and set the value to the name of the secret we created in step 1 (my-registry-secret). Kubernetes will use this secret to authenticate with the container registry when pulling the private-registry/my-image image.

When you apply the modified YAML file to your cluster, Kubernetes will use the specified secret to authenticate with the container registry and pull the private image.

Step4: Final result

For this article I am using “minikube” cluster, so you can see that before creating the deployment we don’t have the docker image “usm87/jenkins-cicd-maven-project:v4”

After creating the deployment, below are the Pod event logs

Now you can see we have the docker image “usm87/jenkins-cicd-maven-project:v4” pulled from the docker hub successfully.

WordPress Installation on the AWS Ubuntu 20.04 Instance

Usman Ahmad — Fri, 13 Jan 2023 14:10:54 +0000

Steps:

AWS Account
Ubuntu 20.04 instance
Prerequisite to setup WordPress
Final verification of WordPress website

AWS Account: You should have AWS account to perform this task

We are using Ubuntu 20.04 OS to set up WordPress.

If you are setting up WordPress just for practice then “t2.micro” instance is fine for this work. Otherwise if you have plan to use this instance for real website then you should use instance type according to the expected load/traffic on your website.

Configure Instances and Add storage options will be remain same (default) but if you are using this instance for your actual website then you should follow AWS best practices.
Configure Security Group we need SSH and HTTP type should be open to the world (*for best practice ssh port 22 should allow just your ip address and after performing your work you should remove it from ingress rule).

Now review and launch
SSH your instance using Putty or command line

Prerequisite to setup WordPress

Install php with all packages
Install apache2
Install mysql-server

Commands: Follow below commands

apt update -y
sudo apt install php libapache2-mod-php php-mysql php-redis
sudo apt install php-curl php-gd php-mbstring php-xml php-xmlrpc php-soap php-intl php-zip
apt install apache2
apt install mysql-server
systemctl enable apache2 mysql
wget -c http://wordpress.org/latest.tar.gz
tar -xzvf latest.tar.gz
mkdir /var/www/wordpress
sudo cp -R wordpress /var/www/wordpress
sudo chown -R www-data:www-data /var/www/wordpress
sudo chmod -R 775 /var/www/html/wordpress
sudo mysql -u root

Now we create database, user with password

CREATE DATABASE wordpress;
CREATE USER 'wpuser'@'localhost' IDENTIFIED BY 'wppassword';
GRANT ALL PRIVILEGES ON * . * TO 'wpuser'@'localhost';
FLUSH PRIVILEGES;
exit

Now we will create .conf file inside site-available

sudo nano /etc/apache2/sites-available/wordpress.conf

Now update the below details in it

<Directory /var/www/wordpress/>
    AllowOverride All
</Directory>

Now run below commands

sudo a2enmod rewrite

Now to test the configurations

sudo apache2ctl configtest
Result: 
Syntax OK
Now restart apache2
sudo systemctl restart apache2

Now access the “wp-config.php” file and add the database credentials

Now we will access WordPress website through our EC2 instance public IP address

Here we have our WordPress website

Now you just need to configure with your website details and enjoy :)