Forem: Mohammad Abu Mattar

How To Setup Bastion Host on AWS using AWS CLI

Mohammad Abu Mattar — Wed, 11 Jan 2023 21:48:30 +0000

Introduction

In today's world, security is the top priority for any infrastructure and applications, that's why a Bastion host is a must-have in your infrastructure if you want to secure your remote connections. A Bastion host is a special-purpose computer on a network specifically designed and configured to withstand attacks. In this post, we will show you how to set up a Bastion host on AWS using the AWS CLI. We will create a Virtual Private Cloud (VPC) and subnets, create an Internet Gateway and configure the Bastion host with the appropriate permissions to access our EC2 instances. By the end of this post, you will have a secure and easy way to remotely access your EC2 instances.

Prerequisites

Before starting, make sure that you have the following:

AWS CLI installed and configured on your local machine. You can follow the instructions on Installing the AWS CLI to install and configure it.
An IAM user with the following permissions:
- AmazonVPCFullAccess
- AmazonEC2FullAccess
Basic knowledge of networking and SSH

To create an IAM user, follow the instructions on Creating an IAM User

You will also need to have the AWS CLI configured with your access keys for the IAM user you created above. This can be done by running aws configure in the command line and providing your access key and secret key.

Create VPC

In this section, we will create a Virtual Private Cloud (VPC) and its resources such as subnets, internet gateways, etc. This VPC will be the foundation for our Bastion Host, providing a secure and isolated network environment.

Step 1: Create VPC

First, we need to create a VPC, run the following command:

AWS_VPC=$(aws ec2 create-vpc \
  --cidr-block 10.0.0.0/16 \
  --query 'Vpc.VpcId' \
  --output text)

aws ec2 create-tags \
  --resources $AWS_VPC \
  --tags Key=Name,Value=vpc

The above command will create a VPC with the CIDR block of 10.0.0.0/16 and create a name tag for it. The VpcId of the created VPC will be stored in the variable $AWS_VPC for future reference.

Step 2: Modify your VPC and enable DNS hostname and DNS support

In this step, we will enable both the DNS hostname and DNS support on our VPC. Enabling these features will allow our instances to resolve DNS hostnames and domain names. By default, these features are disabled when you create a VPC.

aws ec2 modify-vpc-attribute \
  --vpc-id $AWS_VPC \
  --enable-dns-hostnames "{\"Value\":true}"

aws ec2 modify-vpc-attribute \
  --vpc-id $AWS_VPC \
  --enable-dns-support "{\"Value\":true}"

The above commands will enable the DNS hostname and DNS support for our VPC. --vpc-id $AWS_VPC this flag tells the command on which vpc you want to enable these features, where the $AWS_VPC is a variable that we set in the previous step when we created the VPC.

Step 3: Create a Public and a Private subnet

In this step, we will create two subnets: one public and one private. A public subnet is a subnet that's connected to the internet through an internet gateway, whereas a private subnet is a subnet that's isolated from the internet and can only access the internet through a NAT gateway or VPN connection. In this case, we will connect our Bastion Host to the public subnet and the EC2 instances that we want to access remotely to the private subnet.

AWS_PUBLIC_SUBNET=$(aws ec2 create-subnet \
  --vpc-id $AWS_VPC \
  --cidr-block 10.0.0.0/24 \
  --query 'Subnet.SubnetId' \
  --output text)

AWS_PRIVATE_SUBNET=$(aws ec2 create-subnet \
  --vpc-id $AWS_VPC \
  --cidr-block 10.0.16.0/24 \
  --query 'Subnet.SubnetId' \
  --output text)

aws ec2 create-tags \
  --resources $AWS_PUBLIC_SUBNET \
  --tags Key=Name,Value=public-subnet

aws ec2 create-tags \
  --resources $AWS_PRIVATE_SUBNET \
  --tags Key=Name,Value=private-subnet

The above command will create two subnets, one with a CIDR block of 10.0.0.0/24 (public) and one with a CIDR block of 10.0.16.0/24 (private) and will associate them with the $AWS_VPC VPC we created earlier. Also, it will add names to the subnet for the better organization and management, The subnet IDs are stored in the variables $AWS_PUBLIC_SUBNET and $AWS_PRIVATE_SUBNET for future reference.

Step 4: Enable Auto-assign Public IP on the Public Subnet

In this step, we will enable Auto-assign Public IP on the public subnet, which will allow instances launched in this subnet to automatically receive a public IP address. This is necessary for instances that need direct internet access.

aws ec2 modify-subnet-attribute \
  --subnet-id $AWS_PUBLIC_SUBNET \
  --map-public-ip-on-launch

The above command will enable the Auto-assign Public IP feature for the public subnet identified by the $AWS_PUBLIC_SUBNETvariable. This feature tells the AWS to automatically assign a public IP to the instances launched in this subnet.

It's worth noting that, you can also assign public IP addresses to instances by using Elastic IP addresses, a feature that allows you to allocate an IP address to your AWS account and then associate it with an instance. The advantage of Elastic IP addresses is that they can be moved between instances or be released when no longer needed, avoiding the extra charges that come with using an automatically assigned public IP address.

Step 5: Create an Internet Gateway

In this step, we will create an Internet Gateway and associate it with our VPC. An Internet Gateway is a VPC component that allows communication between instances in our VPC and the internet. This is a necessary step for our public subnet instances to have internet access.

AWS_INTERNET_GATEWAY=$(aws ec2 create-internet-gateway \
  --query 'InternetGateway.InternetGatewayId' \
  --output text)

aws ec2 create-tags \
  --resources $AWS_INTERNET_GATEWAY \
  --tags Key=Name,Value=internet-gateway

aws ec2 attach-internet-gateway \
  --vpc-id $AWS_VPC \
  --internet-gateway-id $AWS_INTERNET_GATEWAY

The above command will create an Internet Gateway, create a name tag for it and attach it to the VPC identified by the $AWS_VPC variable. The Internet Gateway ID is stored in the variable $AWS_INTERNET_GATEWAY for future reference.

It's worth noting that, Internet Gateways are stateful, meaning that if a request initiated from your VPC is sent to an Internet Gateway, the response will be routed back to the source. On the other hand, a Virtual Private Gateway is stateless, meaning that it routes traffic but does not hold connection state. It's important to choose the correct type of gateway depending on your use case.

Step 6: Create a Elastic IP

In this step, we will create a Elastic IP, which is a static public IPv4 address that can be allocated to your AWS account and then associated with an instance. Having a Elastic IP address allows you to mask the failure of an instance by rapidly remapping the address to another instance. This is useful when instances fail or if you want to change instances while keeping the same IP address.

AWS_ELASTIC_IP=$(aws ec2 allocate-address \
  --domain vpc \
  --query 'AllocationId' \
  --output text)

aws ec2 create-tags \
  --resources $AWS_ELASTIC_IP \
  --tags Key=Name,Value=elastic-ip

The above command will allocate a new Elastic IP for your AWS account, and create a name tag for it. The Elastic IP address is stored in the variable $AWS_ELASTIC_IP for future reference.

It's worth noting that, Elastic IP addresses are charged for hourly usage when not associated with a running instance or when associated with a stopped instance or an unattached network interface. so, if you're not using it make sure you release it to avoid any charges.

Step 7: Create a NAT Gateway

In this step, we will create a NAT Gateway and associate it with our VPC. A NAT Gateway allows instances in a private subnet to access the internet without exposing their private IP address. It is a highly available, managed service that allows outbound internet traffic from instances in a private subnet in your virtual private cloud (VPC). This is a necessary step for our private subnet instances to have internet access.

AWS_NAT_GATEWAY=$(aws ec2 create-nat-gateway \
  --subnet-id $AWS_PUBLIC_SUBNET \
  --allocation-id $AWS_ELASTIC_IP \
  --query 'NatGateway.NatGatewayId' \
  --output text)

aws ec2 create-tags \
  --resources $AWS_NAT_GATEWAY \
  --tags Key=Name,Value=nat-gateway

The above command will create a NAT Gateway, associated it with the public subnet identified by the $AWS_PUBLIC_SUBNET variable, and using the Elastic IP that we allocated previously identified by $AWS_ELASTIC_IP, also, it will create a name tag for it. The NAT Gateway ID is stored in the variable $AWS_NAT_GATEWAY for future reference.

It's worth noting that, the NAT Gateway requires a pre-allocated Elastic IP in order to be created, and this Elastic IP is consumed by the NAT Gateway and will not be available for other uses. Also, the NAT Gateway is a managed service, which means that AWS will take care of the maintenance and availability of the NAT Gateway, so you don't have to worry about it.

Step 8: Create a Public and a Private Route Table

In this step, we will create two route tables: one public and one private. A route table contains a set of rules, called routes, that are used to determine where network traffic is directed. By creating separate route tables for our public and private subnets, we can ensure that traffic is routed correctly.

AWS_PUBLIC_ROUTE_TABLE=$(aws ec2 create-route-table \
  --vpc-id $AWS_VPC \
  --query 'RouteTable.RouteTableId' \
  --output text)

AWS_PRIVATE_ROUTE_TABLE=$(aws ec2 create-route-table \
  --vpc-id $AWS_VPC \
  --query 'RouteTable.RouteTableId' \
  --output text)

aws ec2 create-tags \
  --resources $AWS_PUBLIC_ROUTE_TABLE \
  --tags Key=Name,Value=public-route-table

aws ec2 create-tags \
  --resources $AWS_PRIVATE_ROUTE_TABLE \
  --tags Key=Name,Value=private-route-table

The above command will create two route tables associated with the VPC identified by the $AWS_VPC variable and create names for them "public-route-table" and "private-route-table" and will store the route table IDs in the variables $AWS_PUBLIC_ROUTE_TABLEand$AWS_PRIVATE_ROUTE_TABLE respectively for future reference.

Step 9: Create a Route in the Public Route Table for Internet Gateway

In this step, we will create a route in the public route table that directs all traffic to the Internet Gateway. This is necessary for instances in the public subnet to have internet access.

aws ec2 create-route \
  --route-table-id $AWS_PUBLIC_ROUTE_TABLE \
  --destination-cidr-block 0.0.0.0/0 \
  --gateway-id $AWS_INTERNET_GATEWAY

The above command will create a route in the public route table that directs all traffic (destination CIDR block 0.0.0.0/0) to the Internet Gateway identified by the $AWS_INTERNET_GATEWAY variable. This will allow instances in the public subnet to access the internet.

It's worth noting that, when you create a route in a route table, the route is propagated to all associated subnets, so it is important to make sure that you are creating the route in the correct route table.

Step 10: Create a Route in the Private Route Table for NAT Gateway

In this step, we will create a route in the private route table that directs all traffic to the NAT Gateway. This is necessary for instances in the private subnet to have internet access without exposing their private IP addresses.

aws ec2 create-route \
  --route-table-id $AWS_PRIVATE_ROUTE_TABLE \
  --destination-cidr-block 0.0.0.0/0 \
  --nat-gateway-id $AWS_NAT_GATEWAY

The above command will create a route in the private route table that directs all traffic (destination CIDR block 0.0.0.0/0) to the NAT Gateway identified by the $AWS_NAT_GATEWAY variable. This will allow instances in the private subnet to access the internet without exposing their private IP addresses.

It's worth noting that, It is important that instances in the private subnet are not able to initiate direct internet access. This will help to protect your instances from malicious Internet traffic and also reduce the risk of accidental data leaks.

Step 11: Associate the Subnets with the Route Tables

In this step, we will associate the public and private subnets with the corresponding public and private route tables. This will ensure that traffic is routed correctly.

aws ec2 associate-route-table \
  --route-table-id $AWS_PUBLIC_ROUTE_TABLE \
  --subnet-id $AWS_PUBLIC_SUBNET

aws ec2 associate-route-table \
  --route-table-id $AWS_PRIVATE_ROUTE_TABLE \
  --subnet-id $AWS_PRIVATE_SUBNET

The above command will associate the public subnet identified by the $AWS_PUBLIC_SUBNET variable with the public route table identified by the $AWS_PUBLIC_ROUTE_TABLE variable, and the private subnet identified by the $AWS_PRIVATE_SUBNET variable with the private route table identified by the $AWS_PRIVATE_ROUTE_TABLE variable.

This ensures that traffic is directed to the correct destination based on the subnet it originates from, by this way, traffic originating from the public subnet will be directed to the Internet Gateway and traffic originating from the private subnet will be directed to the NAT Gateway, this ensures that instances in the public subnet have internet access, and instances in the private subnet have internet access without exposing their private IP addresses.

Step 12: Create Security Groups

In this step, we will create security groups for the bastion host and the instances in the private subnet. Security groups act as a virtual firewall for your instances, controlling inbound and outbound traffic.

AWS_BASTION_SECURITY_GROUP=$(aws ec2 create-security-group \
  --group-name bastion-security-group \
  --description "Security group for the bastion host" \
  --vpc-id $AWS_VPC \
  --query 'GroupId' \
  --output text)

AWS_PRIVATE_SECURITY_GROUP=$(aws ec2 create-security-group \
  --group-name private-security-group \
  --description "Security group for the private instances" \
  --vpc-id $AWS_VPC \
  --query 'GroupId' \
  --output text)

aws ec2 create-tags \
  --resources $AWS_BASTION_SECURITY_GROUP \
  --tags Key=Name,Value=bastion-security-group

aws ec2 create-tags \
  --resources $AWS_PRIVATE_SECURITY_GROUP \
  --tags Key=Name,Value=private-security-group

aws ec2 authorize-security-group-ingress \
  --group-id $AWS_BASTION_SECURITY_GROUP \
  --protocol tcp \
  --port 22 \
  --cidr 0.0.0.0/0 \
  --output text

aws ec2 authorize-security-group-ingress \
  --group-id $AWS_PRIVATE_SECURITY_GROUP \
  --protocol tcp \
  --port 22 \
  --source-group $AWS_BASTION_SECURITY_GROUP \
  --output text

The above command will create two security groups: one for the bastion host, and one for the instances in the private subnet.

The security group for the bastion host is named "bastion-security-group", and it is associated with the VPC identified by the $AWS_VPC variable. It allows inbound traffic on port 22 (SSH) from any IP address (CIDR block 0.0.0.0/0) and It is useful to connect to instances via the bastion host.

The security group for the instances in the private subnet is named "private-security-group", and it is also associated with the VPC identified by the $AWS_VPC variable. It allows all inbound traffic from the security group for the bastion host only, this way, instances in the private subnet can only be accessed via the bastion host and only from instances that are within the security group for the bastion host.

It's worth noting that, These security groups will help ensure that only authorized traffic can reach your instances, and that traffic from your instances to the Internet is properly restricted.

Create a Two EC2 Instances

In this step, we will create two EC2 instances: one for the bastion host and one for the private subnet. Before creating these instances, you need to create an ssh key pair that will be used to access the instances via ssh.

Step 1: Create a Key Pair

In order to connect to the instances via SSH, you will need to create a Key Pair that will be used to authenticate the connection. To create a Key Pair, you can use the AWS Management Console, AWS CLI or SDKs.

AWS_KEY_PAIR=aws-key-pair
aws ec2 create-key-pair \
  --key-name $AWS_KEY_PAIR \
  --query 'KeyMaterial' \
  --output text > $AWS_KEY_PAIR.pem
chmod 400 $AWS_KEY_PAIR.pem

The above command will create a new key pair named aws-key-pair and the private key will be saved in the file aws-key-pair.pem . Make sure to keep this file safe and secure, as it allows you to connect to the instances. The chmod 400 command will restrict the permissions on the key pair file so that it is only readable by the owner.

Also, you may want to consider using environment variables for the key pair name, this way you can easily change the key pair name without having to search and replace it in the script.

Step 2: Get the latest AMI ID for Amazon Linux 2

Before launching an EC2 instance, we need to know the Amazon Machine Image (AMI) ID for the specific Operating System we want to use, in this case Amazon Linux 2. The AMI ID is used to specify the image for the instance when it's being created. Instead of hard coding the AMI ID, it's better to programmatically find the latest available AMI ID for the specific Operating System to ensure that the script will always use the latest version of the AMI.

# Get the latest AMI ID for Amazon Linux 2
AWS_AMI=$(aws ec2 describe-images \
  --owners 'amazon' \
  --filters 'Name=name,Values=amzn2-ami-hvm-2.0.*' \
  'Name=state,Values=available' \
  --query 'sort_by(Images, &CreationDate)[-1].[ImageId]' \
  --output 'text')

The above command will get the latest available Amazon Linux 2 AMI ID based on the filters provided. The --owners option specifies that the AMI should be owned by Amazon. The --filters option is used to filter the images returned by the describe-images command. The Name=name,Values=amzn2-ami-hvm-2.0.* filter will return only the images that have a name that starts with amzn2-ami-hvm-2.0. The Name=state,Values=available filter will return only the images that are in the available state.

Step 3: Create a Bastion Host

In this step, we will use the run-instances command to launch an EC2 instance for our Bastion host. The Bastion host will be used as a jump server to securely access the instances in the private subnet.

AWS_BASTION_HOST=$(aws ec2 run-instances \
  --image-id $AWS_AMI \
  --count 1 \
  --instance-type t2.micro \
  --key-name $AWS_KEY_PAIR \
  --security-group-ids $AWS_BASTION_SECURITY_GROUP \
  --subnet-id $AWS_PUBLIC_SUBNET \
  --associate-public-ip-address \
  --query 'Instances[0].InstanceId' \
  --output text)

aws ec2 create-tags \
  --resources $AWS_BASTION_HOST \
  --tags Key=Name,Value=bastion-host

The above command will create a single EC2 instance in the public subnet with the provided AMI ID and Key Pair, will be associated with the security group that we created earlier for the Bastion host, and it will be assigned a public IP address so that it can be accessed over the internet.

The tag specifications was added to assign the Name value to the created instances.

It's also worth to note that you should consider to specify the availability zone, this way you can ensure that the instances are created in the availability zone that meets your requirements (i.e. the availability zone should have enough capacity to meet the instances requirements, etc.)

Step 4: Create a Private Host

In this step, we will use the run-instances command to launch an EC2 instance for our Private host. The private host will be running in a private subnet and it will not have public IP address.

AWS_PRIVATE_HOST=$(aws ec2 run-instances \
  --image-id $AWS_AMI \
  --count 1 \
  --instance-type t2.micro \
  --key-name $AWS_KEY_PAIR \
  --security-group-ids $AWS_PRIVATE_SECURITY_GROUP \
  --subnet-id $AWS_PRIVATE_SUBNET \
  --query 'Instances[0].InstanceId' \
  --output text)

aws ec2 create-tags \
  --resources $AWS_PRIVATE_HOST \
  --tags Key=Name,Value=private-host

The above command will create a single EC2 instance in the private subnet with the provided AMI ID and Key Pair, will be associated with the security group that we created earlier for the private host, and it will not be assigned a public IP address.

As the bastion host will act as the gateway to access the instances in private subnet via ssh.

Connect to the Private Host

In this section, we will show you how to connect to the Private host using the Bastion host as a jump server.

Step 1: Get the Public IP Address of the Bastion Host

To connect to the private host, we first need to know the public IP address of the Bastion host. We can use the describe-instances command to get the public IP address of the Bastion host.

AWS_BASTION_HOST_PUBLIC_IP=$(aws ec2 describe-instances \
  --instance-ids $AWS_BASTION_HOST \
  --query 'Reservations[0].Instances[0].PublicIpAddress' \
  --output text)

The above command will get the public IP address of the Bastion host based on the instance ID.

Once you have the public IP address of the Bastion host, you can use it to establish an SSH connection to the Bastion host.

Step 2: Connect to the Bastion Host

To connect to the Bastion Host, run the following command:

ssh -i $AWS_KEY_PAIR.pem ec2-user@$AWS_BASTION_HOST_PUBLIC_IP

The above command will connect to the Bastion host using the key pair that we created earlier, and the public IP address of the Bastion host.

Step 3: Get the Private IP Address of the Private Host

To connect to the private host via the Bastion host, we will need to know the private IP address of the private host. We can use the describe-instances command to get the private IP address of the private host.

AWS_PRIVATE_HOST_PRIVATE_IP=$(aws ec2 describe-instances \
  --instance-ids $AWS_PRIVATE_HOST \
  --query 'Reservations[0].Instances[0].PrivateIpAddress' \
  --output text)

The above command will get the private IP address of the private host based on the instance ID and the output will be a text with the private ip address, you can use it in the next step.

It's worth to note that you could also use the Name tag that we created earlier to retrieve the private IP address using the --filters option, this way you can get the private IP address of the private host without knowing the instance ID.

AWS_PRIVATE_HOST_PRIVATE_IP=$(aws ec2 describe-instances \
  --filters "Name=tag:Name,Values=private-host" \
  --query 'Reservations[0].Instances[0].PrivateIpAddress' \
  --output text)

Step 4: Connect to the Private Host

Once you have the private IP address of the private host, you can use the following command to connect to the private host via the Bastion host:

# add the private key
vi ~/.ssh/private-key.pem

# change the permission of the private key
chmod 400 ~/.ssh/private-key.pem

# connect to the private host
ssh -i ~/.ssh/private-key.pem ec2-user@$AWS_PRIVATE_HOST_PRIVATE_IP

The above command will connect to the private host using the private key that we created earlier, and the private IP address of the private host.

Step 5: Check the Internet Connectivity

Now that you are connected to the private host, you can check if the host has internet connectivity by pinging a public IP or URL:

ping -c 4 google.com

The above command will send 4 ICMP echo requests to the IP address of Google's website, and the private host will respond with 4 ICMP echo replies if it can reach the internet. This verifies that the NAT gateway and route tables are configured correctly.

Alternatively, you can also check internet connectivity by using curl command to download a webpage:

curl -s https://www.mkabumattar.tech

This will download the website's source code and will return it to the terminal, and check if the response is received from the website. If the private host has internet connectivity, it will show the webpage's source code.

It is important to note that, if you are running these commands from the bastion host, you might not face the same restrictions as the private host, in that case you should run the commands from the private host, or you could use a specific website for the test that is blocked for your private network

Conclusion

In this tutorial, we walked through the process of creating a Bastion host on AWS using the AWS CLI. We created a VPC, subnets, an Internet gateway, a NAT gateway, route tables, security groups, and two EC2 instances. We then connected to the private host via the Bastion host and verified internet connectivity on the private host.

It is important to note that this is just a basic setup, you might want to improve your security by using a more secure authentication method other than the key pair, such as IAM roles and SSM session manager, also you should consider adding extra logging, auditing, and monitoring to your setup.

Thank you for reading this tutorial and I hope you found it useful. If you have any questions or feedback, feel free to leave a comment below.

Cleanup

When you are finished using the resources created in this tutorial, you should clean them up to avoid incurring unnecessary charges.

You can use the AWS Management Console, or the AWS CLI to delete the resources.

Note: Be careful when running the following commands, as they will delete the resources created in this tutorial

Delete the EC2 Instances

aws ec2 terminate-instances --instance-ids $AWS_BASTION_HOST $AWS_PRIVATE_HOST

This command will delete the two EC2 instances created in this tutorial.

Detach and Delete Internet Gateway

aws ec2 detach-internet-gateway --internet-gateway-id $AWS_INTERNET_GATEWAY --vpc-id $AWS_VPC
aws ec2 delete-internet-gateway --internet-gateway-id $AWS_INTERNET_GATEWAY

This command will detach and delete the Internet gateway created in this tutorial.

Delete Route Tables

aws ec2 delete-route-table --route-table-id $AWS_PUBLIC_ROUTE_TABLE
aws ec2 delete-route-table --route-table-id $AWS_PRIVATE_ROUTE_TABLE

This command will delete the route tables created in this tutorial.

Delete NAT Gateway

aws ec2 delete-nat-gateway --nat-gateway-id $AWS_NAT_GATEWAY

This command will delete the NAT gateway created in this tutorial.

Delete Elastic IP

aws ec2 release-address --public-ip $AWS_ELASTIC_IP

Delete Subnets

aws ec2 delete-subnet --subnet-id $AWS_PUBLIC_SUBNET
aws ec2 delete-subnet --subnet-id $AWS_PRIVATE_SUBNET

This command will delete the subnets created in this tutorial.

Delete Security Groups

aws ec2 delete-security-group --group-id $AWS_BASTION_SECURITY_GROUP
aws ec2 delete-security-group --group-id $AWS_PRIVATE_SECURITY_GROUP

This command will delete the security groups created in this tutorial.

Delete VPC

aws ec2 delete-vpc --vpc-id $AWS_VPC

Delete Key Pair

aws ec2 delete-key-pair --key-name $AWS_KEY_PAIR

This command will delete the key pair created in this tutorial and also the key file from the local system.

It is important to note that some resources may take a while to be fully deleted and some resources are dependent on others, so you may need to run the deletion commands multiple times and in a specific order.

Also, you should check if there are any other resources that were created outside of the scope of this tutorial but are still associated with the VPC, subnet, security groups, and key pairs, and delete them as well.

References

These references should provide you with more in-depth information on the various services and concepts used in this tutorial, such as VPC, EC2, IAM, and the AWS CLI. Additionally, it includes more information about bastion host.
It would be very helpful if you go through those references to gain more knowledge and information in order to improve the setup even more.

How To Connect A EBS Volume To An Windows EC2 Instance Using Powershell/GUI

Mohammad Abu Mattar — Sat, 17 Dec 2022 10:35:09 +0000

Introduction

In this post, we will learn how to connect a EBS volume to an Windows EC2 instance using Powershell/GUI and also how to mount the EBS volume to the EC2 instance.

Prerequisites

AWS CLI installed and configured
IAM user with the following permissions:
- AmazonVPCFullAccess
- AmazonEC2FullAccess
- AmazonElasticBlockStoreFullAccess

Create an VPC

Step 1: Create VPC

To create a VPC, run the following command:

# Create a VPC
AWS_VPC=$(aws ec2 create-vpc \
  --cidr-block 10.0.0.0/16 \
  --query 'Vpc.VpcId' \
  --output text)

# Add a name tag to the VPC
aws ec2 create-tags \
  --resources $AWS_VPC \
  --tags Key=Name,Value=aws-vpc

Explanation:

aws ec2 create-vpc - Create a VPC
--cidr-block - The IPv4 network range for the VPC, in CIDR notation.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.
--resources - The IDs of the resources.
--tags - The tags to apply to the resource.

Step 2: Modify your custom VPC and enable DNS hostname support, and DNS support

To modify your custom VPC and enable DNS hostname support, and DNS support, run the following command:

# Enable DNS hostnames
aws ec2 modify-vpc-attribute \
  --vpc-id $AWS_VPC \
  --enable-dns-hostnames "{\"Value\":true}"

# Enable DNS support
aws ec2 modify-vpc-attribute \
  --vpc-id $AWS_VPC \
  --enable-dns-support "{\"Value\":true}"

Explanation:

aws ec2 modify-vpc-attribute - Modifies the specified attribute of the specified VPC.
--vpc-id - The ID of the VPC.
--enable-dns-hostnames - Indicates whether the instances launched in the VPC get DNS hostnames.
--enable-dns-support - Indicates whether DNS resolution is supported for the VPC.

Step 3: Create a Public Subnet

To create a public subnet, run the following command:

# Create a public subnet
AWS_PUBLIC_SUBNET=$(aws ec2 create-subnet \
  --vpc-id $AWS_VPC \
  --cidr-block 10.0.1.0/24 \
  --query 'Subnet.SubnetId' \
  --output text)

# Add a name tag to the public subnet
aws ec2 create-tags \
  --resources $AWS_PUBLIC_SUBNET \
  --tags Key=Name,Value=aws-public-subnet

Explanation:

aws ec2 create-subnet - Creates a subnet in an existing VPC.
--vpc-id - The ID of the VPC.
--cidr-block - The IPv4 network range for the subnet, in CIDR notation.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.
--resources - The IDs of the resources.
--tags - The tags to apply to the resource.

Step 4: Enable Auto-assign Public IP on the subnet

To enable auto-assign public IP on the subnet, run the following command:

# Enable auto-assign public IP on the subnet
aws ec2 modify-subnet-attribute \
  --subnet-id $AWS_PUBLIC_SUBNET \
  --map-public-ip-on-launch

Explanation:

aws ec2 modify-subnet-attribute - Modifies a subnet attribute.
--subnet-id - The ID of the subnet.
--map-public-ip-on-launch - Specify true to indicate that network interfaces created in the specified subnet should be assigned a public IPv4 address.

Step 5: Create an Internet Gateway

To create an Internet Gateway, run the following command:

# Create an Internet Gateway
AWS_INTERNET_GATEWAY=$(aws ec2 create-internet-gateway \
  --query 'InternetGateway.InternetGatewayId' \
  --output text)

# Add a name tag to the Internet Gateway
aws ec2 create-tags \
  --resources $AWS_INTERNET_GATEWAY \
  --tags Key=Name,Value=aws-internet-gateway

Explanation:

aws ec2 create-internet-gateway - Creates an Internet gateway for use with a VPC.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.
--resources - The IDs of the resources.
--tags - The tags to apply to the resource.

Step 6: Attach the Internet Gateway to the VPC

To attach the Internet Gateway to the VPC, run the following command:

# Attach the Internet Gateway to the VPC
aws ec2 attach-internet-gateway \
  --internet-gateway-id $AWS_INTERNET_GATEWAY \
  --vpc-id $AWS_VPC

Explanation:

aws ec2 attach-internet-gateway - Attaches an Internet gateway to a VPC, enabling connectivity between the Internet and the VPC.
--internet-gateway-id - The ID of the Internet gateway.
--vpc-id - The ID of the VPC.

Step 7: Create a Route Table

To create a route table, run the following command:

# Create a route table
AWS_ROUTE_TABLE=$(aws ec2 create-route-table \
  --vpc-id $AWS_VPC \
  --query 'RouteTable.RouteTableId' \
  --output text)

# Add a name tag to the route table
aws ec2 create-tags \
  --resources $AWS_ROUTE_TABLE \
  --tags Key=Name,Value=aws-route-table

Explanation:

aws ec2 create-route-table - Creates a route table for the specified VPC.
--vpc-id - The ID of the VPC.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.
--resources - The IDs of the resources.
--tags - The tags to apply to the resource.

Step 8: Create a custom route table association

To create a custom route table association, run the following command:

# Create a custom route table association
aws ec2 associate-route-table \
  --subnet-id $AWS_PUBLIC_SUBNET \
  --route-table-id $AWS_ROUTE_TABLE

Explanation:

aws ec2 associate-route-table - Associates a subnet with a route table.
--subnet-id - The ID of the subnet.
--route-table-id - The ID of the route table.

Step 9: Associate the subnet with route table, making it a public subnet

To associate the subnet with route table, making it a public subnet, run the following command:

# Associate the subnet with route table, making it a public subnet
aws ec2 create-route \
  --route-table-id $AWS_ROUTE_TABLE \
  --destination-cidr-block 0.0.0.0/0 \
  --gateway-id $AWS_INTERNET_GATEWAY

Explanation:

aws ec2 create-route - Creates a route in a route table within a VPC.
--route-table-id - The ID of the route table for the route.
--destination-cidr-block - The IPv4 CIDR address block used for the destination match.
--gateway-id - The ID of an Internet gateway or virtual private gateway attached to your VPC.

Step 10: Create a Security Group

To create a security group, run the following command:

# Create a security group
AWS_SECURITY_GROUP=$(aws ec2 create-security-group \
  --group-name aws-security-group \
  --description "AWS Security Group" \
  --vpc-id $AWS_VPC \
  --query 'GroupId' \
  --output text)

# Add a name tag to the security group
aws ec2 create-tags \
  --resources $AWS_SECURITY_GROUP \
  --tags Key=Name,Value=aws-security-group

Explanation:

aws ec2 create-security-group - Creates a security group.
--group-name - The name of the security group.
--description - A description for the security group.
--vpc-id - The ID of the VPC.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.
--resources - The IDs of the resources.
--tags - The tags to apply to the resource.

Step 11: Add a rule to the security group

To add a rule to the security group, run the following command:

# Add a rule to the security group

# Allow RDP >> remote desktop protocol
aws ec2 authorize-security-group-ingress \
  --group-id $AWS_SECURITY_GROUP \
  --protocol tcp \
  --port 3389 \
  --cidr 0.0.0.0/0 \
  --output text

# Add HTTP rule
aws ec2 authorize-security-group-ingress \
  --group-id $AWS_SECURITY_GROUP \
  --protocol tcp \
  --port 80 \
  --cidr 0.0.0.0/0 \
  --output text

# Add HTTPS rule
aws ec2 authorize-security-group-ingress \
  --group-id $AWS_SECURITY_GROUP \
  --protocol tcp \
  --port 443 \
  --cidr 0.0.0.0/0 \
  --output text

Explanation:

aws ec2 authorize-security-group-ingress - Adds one or more ingress rules to a security group.
--group-id - The ID of the security group.
--protocol - The IP protocol name or number.
--port - The port number.
--cidr - The IPv4 CIDR range.
--output - The output format of the command.

Create a Windows Server 2022 EC2 Instance

Step 1: Get the latest AMI ID

To get the latest AMI ID, run the following command:

# Get the latest AMI ID
AWS_AMI=$(aws ec2 describe-images \
--owners 'amazon' \
--filters 'Name=name,Values=Windows_Server-2022-English-Full-Base-2022.11.10' \
'Name=state,Values=available' \
--query 'sort_by(Images, &CreationDate)[-1].[ImageId]' \
--output 'text')

Explanation:

aws ec2 describe-images - Describes one or more of the images (AMIs, AKIs, and ARIs) available to you. Images available to you include public images, private images that you own, and private images owned by other AWS accounts but for which you have explicit launch permissions.
--owners - Filters the images by the owner. Specify an AWS account ID, self (owner is the sender of the request), or an AWS owner alias (valid values are amazon, aws-marketplace, microsoft).
--filters - One or more filters. Use a filter to return a more specific list of results.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.

Step 2: Create a Key Pair

To create a key pair, run the following command:

# Create a key pair
aws ec2 create-key-pair \
  --key-name aws-key-pair \
  --query 'KeyMaterial' \
  --output text > aws-key-pair.pem

# Change the permissions of the key pair
chmod 400 aws-key-pair.pem

Explanation:

aws ec2 create-key-pair - Creates a 2048-bit RSA key pair with the specified name. Amazon EC2 stores the public key and displays the private key for you to save to a file. The private key is returned as an unencrypted PEM encoded PKCS#8 private key. If a key with the specified name already exists, Amazon EC2 returns an error.
--key-name - The name for your key pair.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.

NOTE: The private key, which is returned as an unencrypted PEM encoded PKCS#8 private key, is only returned if you have access to the key pair. You must provide the corresponding key pair file when you launch an instance.

NOTE: The key pair you will decrypted using AWS EC2 console, to get the password.

Step 3: Create an EC2 Instance

To create an EC2 instance, run the following command:

# Create an EC2 instance
AWS_INSTANCE=$(aws ec2 run-instances \
  --image-id $AWS_AMI \
  --instance-type t2.micro \
  --key-name aws-key-pair \
  --monitoring "Enabled=false" \
  --security-group-ids $AWS_SECURITY_GROUP \
  --subnet-id $AWS_PUBLIC_SUBNET \
  --query 'Instances[0].InstanceId' \
  --output text)

# Add a name tag to the EC2 instance
aws ec2 create-tags \
  --resources $AWS_INSTANCE \
  --tags Key=Name,Value=aws-instance-windows

Explanation:

aws ec2 run-instances - Launches the specified number of instances using an AMI for which you have permissions.
--image-id - The ID of the AMI.
--instance-type - The instance type.
--key-name - The name of the key pair.
--monitoring - Enables detailed monitoring (disabled by default).
--security-group-ids - The IDs of the security groups.
--subnet-id - The ID of the subnet in which to launch the instance.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.

Step 4: Wait for the EC2 Instance to be running

To wait for the EC2 instance to be running, run the following command:

# Wait for the EC2 instance to be running
aws ec2 wait instance-running \
  --instance-ids $AWS_INSTANCE

Explanation:

aws ec2 wait instance-running - Wait until an instance is running.
--instance-ids - The IDs of the instances.

Step 5: Get the public IP address of the EC2 Instance

To get the public IP address of the EC2 instance, run the following command:

# Get the public IP address of the EC2 instance
AWS_PUBLIC_IP=$(aws ec2 describe-instances \
  --instance-ids $AWS_INSTANCE \
  --query 'Reservations[0].Instances[0].PublicIpAddress' \
  --output text)

Explanation:

aws ec2 describe-instances - Describes one or more of your instances.
--instance-ids - The IDs of the instances.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.

Create an EBS Volume

Step 1: Create an EBS Volume

To create an EBS volume, run the following command:

# Get the availability zone for the EC2 instance
AWS_AVAILABILITY_ZONE=$(aws ec2 describe-instances \
  --instance-ids $AWS_INSTANCE \
  --query 'Reservations[0].Instances[0].Placement.AvailabilityZone' \
  --output text)

# Create an EBS volume
AWS_VOLUME=$(aws ec2 create-volume \
  --availability-zone $AWS_AVAILABILITY_ZONE \
  --size 10 \
  --volume-type gp2 \
  --query 'VolumeId' \
  --output text)

# Add a name tag to the EBS volume
aws ec2 create-tags \
  --resources $AWS_VOLUME \
  --tags Key=Name,Value=aws-volume

Explanation:

aws ec2 describe-instances - Describes one or more of your instances.
--instance-ids - The IDs of the instances.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.
aws ec2 create-volume - Creates an EBS volume that can be attached to an instance in the same Availability Zone.
--availability-zone - The Availability Zone in which to create the volume.
--size - The size of the volume, in GiBs.
--volume-type - The volume type.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.

NOTE: Availability zone for the EC2 instance and EBS volume must be the same. Otherwise, you will get the following error: InvalidParameterValue: The requested Availability Zone is currently constrained and only m3.medium or m3.large instances can be launched.

Step 2: Wait for the EBS Volume to be available

To wait for the EBS volume to be available, run the following command:

# Wait for the EBS volume to be available
aws ec2 wait volume-available \
  --volume-ids $AWS_VOLUME

Explanation:

aws ec2 wait volume-available - Wait until a volume is in the available state.
--volume-ids - The IDs of the volumes.

Attach the EBS Volume to the EC2 Instance

Step 1: Attach the EBS Volume to the Windows Server EC2 Instance

To attach the EBS volume to the Windows Server EC2 instance, run the following command:

# Attach the EBS volume to the Windows Server EC2 instance
aws ec2 attach-volume \
  --device xvdf \
  --instance-id $AWS_INSTANCE \
  --volume-id $AWS_VOLUME

Explanation:

aws ec2 attach-volume - Attaches an EBS volume to a running or stopped instance and exposes it to the instance with the specified device name.
--device - The device name (for example, /dev/sdh or xvdh).
--instance-id - The ID of the instance.
--volume-id - The ID of the EBS volume.

Step 2: Wait for the EBS Volume to be in-use

To wait for the EBS volume to be in-use, run the following command:

# Wait for the EBS volume to be in-use
aws ec2 wait volume-in-use \
  --volume-ids $AWS_VOLUME

Explanation:

aws ec2 wait volume-in-use - Wait until a volume is in the in-use state.
--volume-ids - The IDs of the volumes.

Connect to the Windows Server EC2 Instance

Step 1: Connect to the Windows Server EC2 Instance using RDP (Remote Desktop Protocol) in Linux

If you are using Linux, you can connect to the Windows Server EC2 instance using RDP (Remote Desktop Protocol) in Linux. To do so, you need to install the remmina package. To install the remmina package, run the following command:

# Install the remmina package

# Arch Linux
sudo pacman -S remmina

# Debian/Ubuntu
sudo apt install remmina -y

# CentOS/RHEL
sudo yum install remmina -y

# Fedora
sudo dnf install remmina -y

# OpenSUSE
sudo zypper install remmina -y

Explanation:

pacman - Arch Linux package manager.
apt - Debian/Ubuntu package manager.
yum - CentOS/RHEL package manager.
dnf - Fedora package manager.
zypper - OpenSUSE package manager.

Step 1.1: Create a new RDP connection

Click on the + button to add a new connection.
Enter the following details:
- Name - Enter a name for the connection.
- Protocol - Select RDP.
- Server - Enter the public IP address of the Windows Server EC2 instance.
- Username - Enter the username of the Windows Server EC2 instance.
- Password - Enter the password of the Windows Server EC2 instance.
Click on the Save button.

NOTE: To get the password of the Windows Server EC2 instance, run the following command:

# Get the password of the Windows Server EC2 instance
EC2_INSTANCE_PASSWORD=$(aws ec2 get-password-data \
  --instance-id $AWS_INSTANCE \
  --priv-launch-key aws-key-pair.pem \
  --query 'PasswordData' \
  --output text)

# Desplay the password of the Windows Server EC2 instance
echo $EC2_INSTANCE_PASSWORD

Explanation:

aws ec2 get-password-data - Retrieves the encrypted administrator password for the instances running Windows.
--instance-id - The ID of the instance.
--priv-launch-key - The private key that is required to decrypt the password data.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.

Step 1.2: Connect to the Windows Server EC2 Instance

Click on the Connect button to connect to the Windows Server EC2 instance.

Step 2: Connect to the Windows Server EC2 Instance using RDP (Remote Desktop Protocol) in Windows

If you are using Windows, you can connect to the Windows Server EC2 instance using RDP (Remote Desktop Protocol) in Windows. To do so, you need to install the Microsoft Remote Desktop app. To install the Microsoft Remote Desktop app, run the following command:

# Install the Microsoft Remote Desktop app
winget install Microsoft.RemoteDesktop

Explanation:

winget - Windows package manager.

Step 2.1: Create a new RDP connection

Click on the + button to add a new connection.
Enter the following details:
- Name - Enter a name for the connection.
- Computer - Enter the public IP address of the Windows Server EC2 instance.
- Username - Enter the username of the Windows Server EC2 instance.
- Password - Enter the password of the Windows Server EC2 instance.

NOTE: To get the password of the Windows Server EC2 instance, run the following command:

# Get the password of the Windows Server EC2 instance
EC2_INSTANCE_PASSWORD=$(aws ec2 get-password-data \
  --instance-id $AWS_INSTANCE \
  --priv-launch-key aws-key-pair.pem \
  --query 'PasswordData' \
  --output text)

# Desplay the password of the Windows Server EC2 instance
echo $EC2_INSTANCE_PASSWORD

Explanation:

aws ec2 get-password-data - Retrieves the encrypted administrator password for the instances running Windows.
--instance-id - The ID of the instance.
--priv-launch-key - The private key that is required to decrypt the password data.
--query - The JMESPath query that is applied to the output.
--output - The output format of the command.

Step 2.2: Connect to the Windows Server EC2 Instance

Click on the Connect button to connect to the Windows Server EC2 instance.

Connect to the EBS Volume

Connect to the EBS Volume using PowerShell

Step 1: Connect to the EBS Volume using PowerShell

Open the PowerShell app.
Run the following command to connect to the EBS volume:

# Connect to diskpart
diskpart

# List the disks
list disk

# Select the disk
select disk 1

# initialize the disk
convert gpt

# Create a new partition
create partition primary

# List the partitions
list partition

# Select the partition
select partition 2

# Assign a drive letter
assign letter=D

# Format the partition
format fs=ntfs quick

# Exit diskpart
exit

Explanation:

diskpart - DiskPart is a command-line tool that you can use to manage disks and volumes.
list disk - Lists all disks on the computer.
select disk - Selects a disk for use.
convert gpt - Converts a disk to the GPT partition style.
create partition primary - Creates a primary partition on the selected disk.
list partition - Lists all partitions on the selected disk.
select partition - Selects a partition for use.
assign letter - Assigns a drive letter to the selected partition.
format fs=ntfs quick - Formats the selected partition.
exit - Exits DiskPart.

Step 2: Check the EBS Volume

Run the following command to check the EBS volume:

# List the disks
Get-Partition | Get-Volume

Explanation:

Get-Partition - Gets the partitions on a disk.
Get-Volume - Gets the volumes on a disk.

Connect to the EBS Volume using Disk Management

Step 1: Connect to the EBS Volume using Disk Management

Open the Sersh bar by pressing the Windows key + S.
Type diskmgmt.msc and press Enter.
Right-click on the Disk 1 and click on the Online option.
Right-click on the Disk 1 and click on the Initialize Disk option.
Right-click on the Unallocated space and click on the New Simple Volume option.
Click on the Next button.
Click on the Next button.
Click on the Next button.
Click on the Finish button.

Step 2: Check the EBS Volume using Disk Management

Right-click on the Disk 1 and click on the Properties option.
Click on the Volumes tab.
Click on the D: drive.

Conclusion

In this tutorial, we learned how to connect a EBS volume to an Windows EC2 instance using PowerShell GUI.

References

How To Create a DynamoDB Table Using AWS CLI

Mohammad Abu Mattar — Tue, 13 Dec 2022 09:37:44 +0000

Introduction

In this article, we will learn how to create a DynamoDB table using AWS CLI. We will also learn how to add items to the table and how to query the table.

Prerequisites

To follow this article, you need to have the following:

AWS CLI
AWS Account
AWS IAM User with the following permissions:
- AmazonDynamoDBFullAccess
AWS CLI configured with the IAM User

Create a DynamoDB Table

Step 1: Create a DynamoDB Table

To create a DynamoDB table, run the following command:

aws dynamodb create-table \
    --table-name MyTable \
    --attribute-definitions \
        AttributeName=Id,AttributeType=S \
    --key-schema \
        AttributeName=Id,KeyType=HASH \
    --provisioned-throughput \
        ReadCapacityUnits=1,WriteCapacityUnits=1

Explanation:

--table-name: The name of the table to create.
--attribute-definitions: An array of attributes that describe the key schema for the table and indexes.
--key-schema: Specifies the attributes that make up the primary key for a table or an index.
--provisioned-throughput: The provisioned throughput settings for the table or index.

Step 2: List the Tables

To list the tables, run the following command:

aws dynamodb list-tables

Step 3: Insert Items to the Table

Step 3.1: Insert an Item Using AWS CLI

To insert items to the table, run the following command:

aws dynamodb put-item \
    --table-name MyTable \
    --item \
        '{"Id": {"S": "1"}, "Name": {"S": "John Doe"}}'

Explanation:

--item: A map of attribute name to attribute values, representing the primary key of the item to be retrieved.

Step 3.2: Insert Multiple Items Using AWS CLI

To insert multiple items to the table, run the following command:

aws dynamodb batch-write-item \
    --request-items \
        '{"MyTable": [{"PutRequest": {"Item": {"Id": {"S": "2"}, "Name": {"S": "Jane Doe"}}}}]}'

Explanation:

--request-items: A map of one or more table names and, for each table, a list of operations to be performed (DeleteRequest or PutRequest).

Step 3.3: Insert Items From a JSON File Using AWS CLI

Create a JSON file with the following content:

# create a JSON file
touch items.json

# open the file
vim items.json

{
  "MyTable": [
    {
      "PutRequest": {
        "Item": {
          "Id": {
            "S": "3"
          },
          "Name": {
            "S": "John Doe"
          }
        }
      }
    },
    {
      "PutRequest": {
        "Item": {
          "Id": {
            "S": "4"
          },
          "Name": {
            "S": "Jane Doe"
          }
        }
      }
    }
  ]
}

To insert items from a JSON file to the table, run the following command:

aws dynamodb batch-write-item \
    --request-items file://items.json

Explanation:

--request-items: A map of one or more table names and, for each table, a list of operations to be performed (DeleteRequest or PutRequest).
file://items.json: The path to the JSON file.

Step 4: Query the Table

Step 4.1: Query the Table Using AWS CLI

To query the table, run the following command:

aws dynamodb query \
    --table-name MyTable \
    --key-condition-expression "Id = :id" \
    --expression-attribute-values  '{":id":{"S":"1"}}'

Explanation:

--key-condition-expression: A condition that evaluates the query results and returns only the desired values.
--expression-attribute-values: One or more values that can be substituted in an expression.

Step 4.2: Query the Table Using AWS CLI and Output to a JSON File

To query the table and output the result to a JSON file, run the following command:

aws dynamodb query \
    --table-name MyTable \
    --key-condition-expression "Id = :id" \
    --expression-attribute-values  '{":id":{"S":"1"}}' \
    --output json > result.json

Explanation:

--output: The output format of the query result.
> result.json: The path to the JSON file.

Step 5: Create a Global Secondary Index

Global Secondary is a secondary index with a partition key and a sort key that can be different from those on the table. You can query the index using the partition key and sort key, or you can query the index using only the partition key.

Step 5.1: Create a Global Secondary Index Using AWS CLI

To create a global secondary index, run the following command:

aws dynamodb update-table \
    --table-name MyTable \
    --attribute-definitions \
        AttributeName=Name,AttributeType=S \
    --global-secondary-index-updates \
        '[{"Create": {"IndexName": "NameIndex", "KeySchema": [{"AttributeName": "Name", "KeyType": "HASH"}], "Projection": {"ProjectionType": "ALL"}, "ProvisionedThroughput": {"ReadCapacityUnits": 1, "WriteCapacityUnits": 1}}}]'

Explanation:

--attribute-definitions: An array of attributes that describe the key schema for the table and indexes.
--global-secondary-index-updates: An array of one or more global secondary indexes to be updated on the table.

Step 6: Remove the Global Secondary Index

Step 6.1: Remove the Global Secondary Index Using AWS CLI

To remove the global secondary index, run the following command:

aws dynamodb update-table \
    --table-name MyTable \
    --global-secondary-index-updates \
        '[{"Delete": {"IndexName": "NameIndex"}}]'

Explanation:

--global-secondary-index-updates: An array of one or more global secondary indexes to be updated on the table.

Step 7: Create Two DynamoDB Tables With Relationships

Step 7.1: Create the First Table

To create the first table, run the following command:

aws dynamodb create-table \
    --table-name User \
    --attribute-definitions \
        AttributeName=Id,AttributeType=S \
    --key-schema \
        AttributeName=Id,KeyType=HASH \
    --provisioned-throughput \
        ReadCapacityUnits=1,WriteCapacityUnits=1

Explanation:

--table-name: The name of the table to be created.
--attribute-definitions: An array of attributes that describe the key schema for the table and indexes.
--key-schema: Specifies the attributes that make up the primary key for a table or an index.
--provisioned-throughput: The provisioned throughput settings for the table or index.

Step 7.2: Create the Second Table

To create the second table, run the following command:

aws dynamodb create-table \
    --table-name Post \
    --attribute-definitions \
        AttributeName=Id,AttributeType=S \
        AttributeName=UserId,AttributeType=S \
    --key-schema \
        AttributeName=Id,KeyType=HASH \
    --global-secondary-indexes \
        '[{"IndexName": "UserIdIndex", "KeySchema": [{"AttributeName": "UserId", "KeyType": "HASH"}], "Projection": {"ProjectionType": "ALL"}, "ProvisionedThroughput": {"ReadCapacityUnits": 1, "WriteCapacityUnits": 1}}]' \
    --provisioned-throughput \
        ReadCapacityUnits=1,WriteCapacityUnits=1

Explanation:

--table-name: The name of the table to be created.
--attribute-definitions: An array of attributes that describe the key schema for the table and indexes.
--key-schema: Specifies the attributes that make up the primary key for a table or an index.
--global-secondary-indexes: One or more global secondary indexes (the maximum is 20) to be created on the table.
--provisioned-throughput: The provisioned throughput settings for the table or index.

Step 7.3: Add Items to the First Table

To add items to the first table, run the following command:

aws dynamodb batch-write-item \
    --request-items \
        '{"User": [{"PutRequest": {"Item": {"Id": {"S": "1"}, "Name": {"S": "John Doe"}}}}]}'

Explanation:

--request-items: A map of one or more table names and, for each table, a list of operations to be performed (DeleteRequest or PutRequest).

Step 7.4: Add Items to the Second Table

To add items to the second table, run the following command:

aws dynamodb batch-write-item \
    --request-items \
        '{"Post": [{"PutRequest": {"Item": {"Id": {"S": "1"}, "UserId": {"S": "1"}, "Title": {"S": "Hello World"}}}}]}'

Explanation:

--request-items: A map of one or more table names and, for each table, a list of operations to be performed (DeleteRequest or PutRequest).

Step 7.5: Query the Second Table Using AWS CLI

To query the second table, run the following command:

aws dynamodb query \
    --table-name Post \
    --index-name UserIdIndex \
    --key-condition-expression "UserId = :userId" \
    --expression-attribute-values  '{":userId":{"S":"1"}}'

Explanation:

--table-name: The name of the table containing the requested items.
--index-name: The name of a global secondary index to be queried.
--key-condition-expression: A condition that evaluates the query results and returns only the desired values.
--expression-attribute-values: One or more values that can be substituted in an expression.

Step 8: Create a DynamoDB Table With a Local Secondary Index

Step 8.1: Create the Table

To create the table, run the following command:

aws dynamodb create-table \
    --table-name MyTable \
    --attribute-definitions \
        AttributeName=Id,AttributeType=S \
        AttributeName=Name,AttributeType=S \
    --key-schema \
        AttributeName=Id,KeyType=HASH \
        AttributeName=Name,KeyType=RANGE \
    --local-secondary-indexes \
        '[{"IndexName": "NameIndex", "KeySchema": [{"AttributeName": "Id", "KeyType": "HASH"}, {"AttributeName": "Name", "KeyType": "RANGE"}], "Projection": {"ProjectionType": "ALL"}}]' \
    --provisioned-throughput \
        ReadCapacityUnits=1,WriteCapacityUnits=1

Explanation:

--table-name: The name of the table to be created.
--attribute-definitions: An array of attributes that describe the key schema for the table and indexes.
--key-schema: Specifies the attributes that make up the primary key for a table or an index.
--local-secondary-indexes: One or more local secondary indexes (the maximum is 5) to be created on the table.
--provisioned-throughput: The provisioned throughput settings for the table or index.

Step 8.2: Add Items to the Table

To add items to the table, run the following command:

aws dynamodb batch-write-item \
    --request-items \
        '{"MyTable": [{"PutRequest": {"Item": {"Id": {"S": "1"}, "Name": {"S": "John Doe"}}}}]}'

Explanation:

--request-items: A map of one or more table names and, for each table, a list of operations to be performed (DeleteRequest or PutRequest).

Step 8.3: Query the Table Using AWS CLI

To query the table, run the following command:

aws dynamodb query \
    --table-name MyTable \
    --index-name NameIndex \
    --key-condition-expression "Id = :id" \
    --expression-attribute-values  '{":id":{"S":"1"}}'

Explanation:

--table-name: The name of the table containing the requested items.
--index-name: The name of a local secondary index to be queried.
--key-condition-expression: A condition that evaluates the query results and returns only the desired values.
--expression-attribute-values: One or more values that can be substituted in an expression.

Step 9: Describe a DynamoDB Table Using AWS CLI

Describe is used to get information about a table, such as the table status, creation date, and primary key schema.

To describe a table, run the following command:

aws dynamodb describe-table \
    --table-name MyTable

Step 10: Delete a DynamoDB Table Using AWS CLI

Delete is used to remove a table and all of its items.

To delete a table, run the following command:

aws dynamodb delete-table \
    --table-name MyTable

Conclusion

In this tutorial, you learned how to use the AWS CLI to create, query, and delete DynamoDB tables. You also learned how to use the AWS CLI to create, query, and delete DynamoDB tables with global and local secondary indexes.

References

How To Create An AWS EC2 Instance Using AWS CLI

Mohammad Abu Mattar — Wed, 07 Dec 2022 18:40:20 +0000

Introduction

We will learn how to create an AWS EC2 instance using AWS CLI in this tutorial. We will also discover how to set up an AWS EC2 instance so that it functions with the Apache web server. We will also discover how to set up an AWS EC2 instance so that it functions with WordPress.

Prerequisites

To follow along with this tutorial, you will need:

An AWS account.
An AWS IAM user with the following permissions:
- AmazonEC2FullAccess
- AmazonVPCFullAccess
An AWS CLI installed on your computer.
An SSH client installed on your computer.

Create an AWS VPC

Before we create an AWS EC2 instance using AWS CLI, we need to create a VPC. We will also create a public and private subnet, an internet gateway, and a route table.

Create an VPC

To create a VPC, run the following command:

# Create a VPC
AWS_VPC=$(aws ec2 create-vpc \
--cidr-block 10.0.0.0/16 \
--query 'Vpc.{VpcId:VpcId}' \
--output text)

# Add a name tag to the VPC
aws ec2 create-tags \
--resources $AWS_VPC \
--tags Key=Name,Value=DevOpsVPC

Modify your custom VPC and enable DNS hostname support, and DNS support

To modify your custom VPC and enable DNS hostname support, and DNS support, run the following command:

# Enable DNS hostnames
aws ec2 modify-vpc-attribute \
--vpc-id $AWS_VPC \
--enable-dns-hostnames "{\"Value\":true}"

# Enable DNS support
aws ec2 modify-vpc-attribute \
--vpc-id $AWS_VPC \
--enable-dns-support "{\"Value\":true}"

Create a Public Subnet

To create a public subnet, run the following command:

# Create a public subnet
AWS_PUBLIC_SUBNET=$(aws ec2 create-subnet \
--vpc-id $AWS_VPC \
--cidr-block 10.0.1.0/24 \
--availability-zone us-east-1a \
--query 'Subnet.{SubnetId:SubnetId}' \
--output text)

# Add a name tag to the public subnet
aws ec2 create-tags \
--resources $AWS_PUBLIC_SUBNET \
--tags Key=Name,Value=DevOpsPublicSubnet

Create a Private Subnet

To create a private subnet, run the following command:

# create a private subnet
AWS_PRIVATE_SUBNET=$(aws ec2 create-subnet \
--vpc-id $AWS_VPC \
--cidr-block 10.0.2.0/24 \
--availability-zone us-east-1a \
--query 'Subnet.{SubnetId:SubnetId}' \
--output text)

# Add a name tag to the private subnet
aws ec2 create-tags \
--resources $AWS_PRIVATE_SUBNET \
--tags Key=Name,Value=DevOpsPrivateSubnet

Enable Auto-assign Public IP on the subnet

To enable auto-assign public IP on the subnet, run the following command:

# Enable auto-assign public IP on the public subnet
aws ec2 modify-subnet-attribute \
--subnet-id $AWS_PUBLIC_SUBNET \
--map-public-ip-on-launch

Create an Internet Gateway

To create an internet gateway, run the following command:

AWS_INTERNET_GATEWAY=$(aws ec2 create-internet-gateway \
--query 'InternetGateway.{InternetGatewayId:InternetGatewayId}' \
--output text)

# Add a name tag to the Internet Gateway
aws ec2 create-tags \
--resources $AWS_INTERNET_GATEWAY \
--tags Key=Name,Value=DevOpsInternetGateway

Create an NAT gateway

To create an NAT gateway, run the following command:

# Get Elastic IP
AWS_ELASTIC_IP=$(aws ec2 allocate-address \
--domain vpc \
--query 'AllocationId' \
--output text)

# Create a NAT gateway
AWS_NAT_GATEWAY=$(aws ec2 create-nat-gateway \
--subnet-id $AWS_PUBLIC_SUBNET \
--allocation-id $AWS_EIP_ALLOCATION \
--query 'NatGateway.{NatGatewayId:NatGatewayId}' \
--output text)

# Add a name tag to the NAT gateway
aws ec2 create-tags \
--resources $AWS_NAT_GATEWAY \
--tags Key=Name,Value=DevOpsNATGateway

Attach the Internet gateway to your VPC

To attach the Internet gateway to your VPC, run the following command:

# Attach the Internet gateway to your VPC
aws ec2 attach-internet-gateway \
--vpc-id $AWS_VPC \
--internet-gateway-id $AWS_INTERNET_GATEWAY \
--query 'InternetGateway.{InternetGatewayId:InternetGatewayId}' \
--output text

Create a custom route table

To create a route table, run the following command:

# Create a custom route table
AWS_ROUTE_TABLE=$(aws ec2 create-route-table \
--vpc-id $AWS_VPC \
--query 'RouteTable.{RouteTableId:RouteTableId}' \
--output text)

# Add a name tag to the route table
aws ec2 create-tags \
--resources $AWS_ROUTE_TABLE \
--tags Key=Name,Value=DevOpsRouteTable

Create a custom route table association

To create a custom route table association, run the following command:

# Create a custom route table association
aws ec2 associate-route-table \
--route-table-id $AWS_ROUTE_TABLE \
--subnet-id $AWS_PUBLIC_SUBNET \
--output text

Associate the subnet with route table, making it a public subnet

To associate the subnet with route table, making it a public subnet, run the following command:

# Associate the subnet with route table, making it a public subnet
aws ec2 create-route \
--route-table-id $AWS_ROUTE_TABLE \
--destination-cidr-block 0.0.0.0/0 \
--gateway-id $AWS_INTERNET_GATEWAY \
--output text

Associate the NAT gateway with the route table, making it a private subnet

To associate the NAT gateway with the route table, making it a private subnet, run the following command:

# Associate the NAT gateway with the route table, making it a private subnet
aws ec2 create-route \
--route-table-id $AWS_ROUTE_TABLE \
--destination-cidr-block 10.2.0.0/24 \
--nat-gateway-id $AWS_NAT_GATEWAY \
--output text

Create a security group

To create a security group, run the following command:

# Create a security group
AWS_SECURITY_GROUP=$(aws ec2 create-security-group \
--group-name DevOpsSG \
--description "DevOps Security Group" \
--vpc-id $AWS_VPC \
--query 'GroupId' \
--output text)

# Add a name tag to the security group
aws ec2 create-tags \
--resources $AWS_SECURITY_GROUP \
--tags Key=Name,Value=DevOpsSG

Add a rule to the security group

To add a rule to the security group, run the following command:

# Add a rule to the security group

# Add SSH rule
aws ec2 authorize-security-group-ingress \
--group-id $AWS_SECURITY_GROUP \
--protocol tcp \
--port 22 \
--cidr 0.0.0.0/0 \
--output text

# Add HTTP rule
aws ec2 authorize-security-group-ingress \
--group-id $AWS_SECURITY_GROUP \
--protocol tcp \
--port 80 \
--cidr 0.0.0.0/0 \
--output text

Create an AWS EC2 instance

Get the latest AMI ID

To get the latest AMI ID, run the following command:

# Get the latest AMI ID
AWS_AMI=$(aws ec2 describe-images \
--owners 'amazon' \
--filters 'Name=name,Values=amzn2-ami-hvm-2.0.20221004.0-x86_64-gp2' \
'Name=state,Values=available' \
--query 'sort_by(Images, &CreationDate)[-1].[ImageId]' \
--output 'text')

Create a key pair

To create a key pair, run the following command:

# Create a key pair
aws ec2 create-key-pair \
--key-name DevOpsKeyPair \
--query 'KeyMaterial' \
--output text > DevOpsKeyPair.pem

# Change the permission of the key pair
chmod 400 DevOpsKeyPair.pem

Create an EC2 instance

Before creating an EC2 instance, you need to create a user data script. That script will be automation previous three blog posts:

You can find the user data script in the GitHub repository

# Create a bash script to update packages, install git and clone the repo, and run the script
cat <<EOF > install.sh
#!/bin/bash

# Update packages
sudo yum update -y

# Install git
sudo yum install git -y

# Clone the repo
git clone https://github.com/MKAbuMattar/install-and-setup-wordpress-on-amazon-linux-2.git

# Run the script
bash install-and-setup-wordpress-on-amazon-linux-2/script.sh mkabumattar 121612 121612 wordpressdb wordpressuser password
EOF

To create an EC2 instance, run the following command:

# Create an EC2 instance
AWS_EC2_INSTANCE=$(aws ec2 run-instances \
--image-id $AWS_AMI \
--instance-type t2.micro \
--key-name DevOpsKeyPair \
--monitoring "Enabled=false" \
--security-group-ids $AWS_SECURITY_GROUP \
--subnet-id $AWS_PUBLIC_SUBNET \
--user-data file://install.sh \
--private-ip-address 10.0.1.10 \
--query 'Instances[0].InstanceId' \
--output text)

# Add a name tag to the EC2 instance
aws ec2 create-tags \
--resources $AWS_EC2_INSTANCE \
--tags "Key=Name,Value=DevOpsInstance"

Check the status of the EC2 instance

To check the status of the EC2 instance, run the following command:

# Check the status of the EC2 instance
aws ec2 describe-instances \
--instance-ids $AWS_EC2_INSTANCE \
--query 'Reservations[*].Instances[*].[InstanceId,State.Name,PublicIpAddress]' \
--output text

Get the public ip address of your instance

To get the public ip address of your instance, run the following command:

# Get the public ip address of your instance
AWS_PUBLIC_IP=$(aws ec2 describe-instances \
--instance-ids $AWS_EC2_INSTANCE \
--query 'Reservations[*].Instances[*].[PublicIpAddress]' \
--output text)

echo $AWS_EC2_INSTANCE_PUBLIC_IP

SSH into the EC2 instance

To SSH into the EC2 instance, run the following command:

# SSH into the EC2 instance
ssh -i DevOpsKeyPair.pem ec2-user@$AWS_PUBLIC_IP

Show the WordPress website

Conclusion

In this blog post, you learned how to create a VPC, a public subnet, a private subnet, a NAT gateway, a route table, a security group, and an EC2 instance. You also learned how to SSH into the EC2 instance.

References

How to Install and Configure Node.js on EC2 Instance Amazon Linux 2

Mohammad Abu Mattar — Mon, 05 Dec 2022 09:18:57 +0000

Introduction

Node.js does not exist in the default Amazon Linux 2 repository. So, we need to add the Node.js repository to the system. In this post, we will learn how to install and configure Node.js on EC2 Instance Amazon Linux 2.

Prerequisites

AWS Account
EC2 Instance Amazon Linux 2
SSH Client

Step 1: Update the System Packages and Install Dependencies Packages

First, we need to update the system packages and install dependencies packages.

# Update the system packages
sudo yum update -y

# Install dependencies packages
sudo yum install gcc-c++ make -y

Step 2: Install Node.js

First, we need to install Node.js on our EC2 Instance. To do that, we need to add the Node.js repository to the system. To add the Node.js repository, we need to run the following command:

# Install Node.js repository 14.x
curl -sL https://rpm.nodesource.com/setup_14.x | sudo bash -

# Install Node.js repository 16.x
curl -sL https://rpm.nodesource.com/setup_16.x | sudo bash -

# Install Node.js repository 17.x
curl -sL https://rpm.nodesource.com/setup_17.x | sudo bash -

Step 3: Install Node.js

After choosing the Node.js version, we need to install Node.js on our EC2 Instance. To do that, we need to run the following command:

# update the system
sudo yum update -y

# Install Node.js
sudo yum install nodejs -y

Step 4: Check Node.js Version

After installing Node.js, we need to check the Node.js version. To do that, we need to run the following command:

node -v

Output depends on the Node.js version that you choose.

# Node.js 14.x
v14.21.3

# Node.js 16.x
v16.19.1

# Node.js 17.x
v17.9.0

Conclusion

In this post, we learned how to install and configure Node.js on EC2 Instance Amazon Linux 2. We learned how to add the Node.js repository to the system and install Node.js on our EC2 Instance.

References

Setup Nextjs Tailwind CSS Styled Components with TypeScript

Mohammad Abu Mattar — Sun, 04 Dec 2022 08:59:51 +0000

Introduction

In this post, we will setup Nextjs Tailwind CSS Styled Components with TypeScript, and we will use the following tools:

Nextjs
Tailwind CSS
Styled Components
TypeScript

Prerequisites

You need to have the following tools installed on your system:

Node.js
Yarn

Setup Nextjs App

Step 1: Create a Nextjs app

First, we will create a Nextjs app using the following command:

# Create a Nextjs app
yarn create next-app nextjs-tailwind-styled-components-typescript

Then, you will be asked to choose a TypeScript and ESLint, choose the following options:

# Choose a TypeScript
✔ Would you like to use TypeScript with this project? … No / Yes # Choose Yes

# Choose a ESLint
✔ Would you like to use ESLint with this project? … No / Yes # Choose Yes

Step 2: Go to the Nextjs app directory

After creating the Nextjs app, we need to go to the Nextjs app directory using the following command:

# Go to the Nextjs app directory
cd nextjs-tailwind-styled-components-typescript

Step 3: Prepare the Nextjs app

First, we need to install the following dependencies:

# Install the following dependencies
yarn add -D eslint-config-prettier eslint-plugin-prettier prettier

Next, we need to create a .npmrc file in the root directory of the Nextjs app, and we will add the following content to the .npmrc file:

# Create a .npmrc file
touch .npmrc

# Add the following content to the .npmrc file
shamefully-hoist=true
engine-strict=true
save-exact = true
tag-version-prefix=""
strict-peer-dependencies = false
auto-install-peers = true
lockfile = true

After, we need to create a .nvmrc file in the root directory of the Nextjs app, and we will add the following content to the .nvmrc file:

# Create a .nvmrc file
touch .nvmrc

# Add the following content to the .nvmrc file
lts/fermium

Then, we need to create a .yarnrc file in the root directory of the Nextjs app, and we will add the following content to the .yarnrc file:

# Create a .yarnrc file
touch .yarnrc

# Add the following content to the .yarnrc file
--install.ignore-engines true

Then, we need to create a .prettierrc file in the root directory of the Nextjs app, and we will add the following content to the .prettierrc file:

# Create a .prettierrc file
touch .prettierrc

# Add the following content to the .prettierrc file
{
  "printWidth": 80,
  "tabWidth": 2,
  "useTabs": false,
  "semi": true,
  "singleQuote": true,
  "quoteProps": "as-needed",
  "jsxSingleQuote": false,
  "trailingComma": "es5",
  "bracketSpacing": true,
  "jsxBracketSameLine": false,
  "arrowParens": "always",
  "requirePragma": false,
  "insertPragma": false,
  "proseWrap": "preserve",
  "htmlWhitespaceSensitivity": "css",
  "endOfLine": "lf"
}

Then, we need to create a .prettierignore file in the root directory of the Nextjs app, and we will add the following content to the .prettierignore file:

# Create a .prettierignore file
touch .prettierignore

# Add the following content to the .prettierignore file
.yarn
.vscode
.next
dist
node_modules

Then, we need to create a .eslintrc file in the root directory of the Nextjs app, and we will add the following content to the .eslintrc file:

# Create a .eslintrc file
touch .eslintrc

# Add the following content to the .eslintrc file
{
  "extends": ["next", "next/core-web-vitals", "plugin:prettier/recommended"],
  "rules": {
    "prettier/prettier": ["error", {}, { "usePrettierrc": true }]
  }
}

Then, we need to create a .eslintignore file in the root directory of the Nextjs app, and we will add the following content to the .eslintignore file:

# Create a .eslintignore file
touch .eslintignore

# Add the following content to the .eslintignore file
.yarn
.vscode
.next
dist
node_modules

Add, the engines field to the package.json file, and we will add the following content to the package.json file:

# Add the following content to the package.json file
{
  "engines": {
    "node": ">=16.0.0",
    "yarn": ">=1.22.0",
    "npm": "please-use-yarn"
  },
}

Step 4: Install Tailwind CSS

First, we will install Tailwind CSS using the following command:

# Install Tailwind CSS
yarn add -D tailwindcss@latest postcss@latest autoprefixer@latest

Then, we will create a Tailwind CSS configuration file using the following command:

# Create a Tailwind CSS configuration file
npx tailwindcss init -p

After, we will change the tailwind.config.js file, and we will add the following content to the tailwind.config.js file:

// Add the following content to the tailwind.config.js file
/** @type {import('tailwindcss').Config} */

module.exports = {
  content: ['./src/**/*.{js,ts,jsx,tsx}'],
  theme: {
    extend: {},
  },
  plugins: [],
};

Step 5: Install Styled Components

First, we will install Styled Components using the following command:

# Install Styled Components
yarn add styled-components

# Install Styled Components TypeScript
yarn add -D @types/styled-components

# Install Styled Components Babel Plugin
yarn add -D babel-plugin-styled-components

Then, we will create a .babelrc file in the root directory of the Nextjs app using the following command:

# Create a .babelrc file
touch .babelrc

Then, we will add the following code to the .babelrc file:

{
  "presets": ["next/babel"],
  "plugins": [
    [
      "styled-components",
      {
        "ssr": true,
        "displayName": true,
        "preprocess": false
      }
    ]
  ]
}

Step 6: Install and Setup `twin.macro`

First, we will install twin.macro using the following command:

# Install twin.macro
yarn add twin.macro

# Install twin.macro Babel Plugin
yarn add -D babel-plugin-twin

Then, we will add the following code to the .babelrc file:

{
  "presets": ["next/babel"],
  "plugins": [
    [
      "styled-components",
      {
        "ssr": true,
        "displayName": true,
        "preprocess": false
      }
    ],
    [
      "babel-plugin-twin",
      {
        "debug": false,
        "styled": "styled-components"
      }
    ],
    "babel-plugin-macros"
  ]
}

Add, the babelMacros field to the package.json file, and we will add the following content to the package.json file:

# Add the following content to the package.json file
{
  "babelMacros": {
    "twin": {
      "styled": {
        "import": "default",
        "from": "styled-components"
      }
    }
  }
}

Step 7: Setup `_document.tsx`

First, we will create a pages/_document.tsx file using the following command:

# Create a pages/_document.tsx file
touch pages/_document.tsx

Then, we will add the following code to the pages/_document.tsx file:

import Document, {
  DocumentContext,
  Head,
  Html,
  Main,
  NextScript,
} from 'next/document';
import { ServerStyleSheet } from 'styled-components';

export default class _Document extends Document {
  static async getInitialProps(ctx: DocumentContext) {
    const sheet = new ServerStyleSheet();
    const originalRenderPage = ctx.renderPage;

    try {
      ctx.renderPage = () =>
        originalRenderPage({
          enhanceApp: (App) => (props) =>
            sheet.collectStyles(<App {...props} />),
        });

      const initialProps = await Document.getInitialProps(ctx);
      return {
        ...initialProps,
        styles: (
          <>
            {initialProps.styles}
            {sheet.getStyleElement()}
          </>
        ),
      };
    } finally {
      sheet.seal();
    }
  }

  render() {
    return (
      <Html>
        <Head>
          <meta name="theme-color" content="#000000" />
        </Head>
        <body>
          <Main />
          <NextScript />
        </body>
      </Html>
    );
  }
}

Step 8: Setup `_app.tsx`

We will add the following code to the pages/_app.tsx file:

import type { AppProps } from 'next/app';
import Head from 'next/head';

import 'tailwindcss/tailwind.css';

const _App = ({ Component, pageProps }: AppProps) => {
  return (
    <>
      <Head>
        <meta name="viewport" content="width=device-width, initial-scale=1" />
        <title>Create Next App</title>
        <meta name="description" content="Generated by create next app" />
        <link rel="icon" href="/favicon.ico" />
      </Head>
      <Component {...pageProps} />;
    </>
  );
};

export default _App;

Step 9: Start styling

We will create a styles directory in the root directory of the Nextjs app using the following command:

# Create a styles directory
mkdir styles

Then, we will create a main.ts file in the styles directory using the following command:

# Create a styles/main.ts file
touch styles/main.ts

Then, we will add the following code to the styles/main.ts file:

import styled from 'styled-components';
import tw from 'twin.macro';

export const Container = tw.div`
  flex
  min-h-screen
  flex-col
  items-center
  justify-center
  py-2
`;

export const Main = tw.main`
  flex
  w-full
  flex-1
  flex-col
  items-center
  justify-center
  px-20
  text-center
`;

export const Title = tw.h1`
  text-6xl
  font-bold
`;

export const TitleLink = tw.a`
  text-blue-600
`;

export const Description = tw.p`
  mt-3
  text-2xl
`;

export const DescriptionCodeHighlight = tw.code`
  rounded-md
  bg-gray-100
  p-3
  font-mono 
  text-lg
`;

export const Cards = tw.div`
  mt-6 flex
  max-w-4xl
  flex-wrap
  items-center
  justify-around
  sm:w-full
`;

export const Card = tw.a`
  mt-6
  w-96
  rounded-xl
  border
  p-6
  text-left
  hover:text-blue-600
  focus:text-blue-600
`;

export const CardTitle = tw.h3`
  text-2xl
  font-bold
`;

export const CardDescription = tw.p`
  mt-4
  text-xl
`;

export const Footer = tw.footer`
  flex
  h-24
  w-full
  items-center
  justify-center
  border-t
`;

export const FooterCopyRight = tw.a`
  flex
  items-center
  justify-center
  gap-2
`;

Then, we will redisign the pages/index.tsx file using the following code:

import type { NextPage } from 'next';
import Image from 'next/image';

import {
  Container,
  Main,
  Title,
  TitleLink,
  Description,
  DescriptionCodeHighlight,
  Cards,
  Card,
  CardTitle,
  Footer,
  FooterCopyRight,
} from '../styles/Home.styles';

const HomePage: NextPage = () => {
  return (
    <Container>
      <Main>
        <Title>
          Welcome to <TitleLink href="https://nextjs.org">Next.js!</TitleLink>
        </Title>

        <Description>
          Get started by editing{' '}
          <DescriptionCodeHighlight>pages/index.tsx</DescriptionCodeHighlight>
        </Description>

        <Cards>
          <Card href="https://nextjs.org/docs">
            <CardTitle>Documentation &rarr;</CardTitle>
            <p>Find in-depth information about Next.js features and API.</p>
          </Card>

          <Card href="https://nextjs.org/learn">
            <CardTitle>Learn &rarr;</CardTitle>
            <p>Learn about Next.js in an interactive course with quizzes!</p>
          </Card>

          <Card href="https://github.com/vercel/next.js/tree/canary/examples">
            <CardTitle>Examples &rarr;</CardTitle>
            <p>Discover and deploy boilerplate example Next.js projects.</p>
          </Card>

          <Card
            href="https://vercel.com/new?utm_source=create-next-app&utm_medium=default-template&utm_campaign=create-next-app"
            target="_blank"
            rel="noopener noreferrer"
          >
            <h2>Deploy &rarr;</h2>
            <p>
              Instantly deploy your Next.js site to a public URL with Vercel.
            </p>
          </Card>
        </Cards>
      </Main>

      <Footer>
        <FooterCopyRight
          href="https://vercel.com?utm_source=create-next-app&utm_medium=default-template&utm_campaign=create-next-app"
          target="_blank"
          rel="noopener noreferrer"
        >
          Powered by{' '}
          <Image src="/vercel.svg" alt="Vercel Logo" width={72} height={16} />
        </FooterCopyRight>
      </Footer>
    </Container>
  );
};

export default HomePage;

Source Code

The source code for this tutorial is available on GitHub

Live Demo

The live demo for this tutorial is available on Vercel

Conclusion

In this tutorial, we have learned how to use Tailwind CSS with Nextjs and Styled Components. We have also learned how to use TypeScript with Nextjs and Styled Components.

References

How to Install WordPress on Amazon Linux 2

Mohammad Abu Mattar — Sat, 03 Dec 2022 12:23:42 +0000

Introduction

We will learn how to install WordPress on Amazon Linux 2 in this tutorial. We will also discover how to set up WordPress so that it functions with the Apache web server. We will also discover how to set up WordPress so that it functions with PHP and MariaDB.

Prerequisites

To follow along with this tutorial, you will need:

An Amazon Linux 2 EC2 instance with a public IP address.
A non-root user with sudo privileges.
A domain name pointing to the public IP address of your EC2 instance.
Apache web server installed and running. How to Install Apache Web Server on Amazon Linux 2.
PHP installed and running. How to Install PHP and MariaDB on Amazon Linux 2.

Installing WordPress, setting up WordPress, and running a basic WordPress demo

Step 1 — Download WordPress

WordPress is a free and open-source content management system (CMS) based on PHP and MySQL. It is the most popular CMS in the world.

To download WordPress, run the following command:



sudo wget https://wordpress.org/latest.tar.gz

Step 2 — Extract WordPress

To extract the WordPress archive, run the following command:



sudo tar -xzvf latest.tar.gz

Next, move the extracted WordPress directory to the /var/www/html directory:



sudo mv wordpress /var/www/html/

Step 3 — Create a WordPress Database

To create a WordPress database, run the following command:



sudo mysql -u root -p

Next, create a database for WordPress:



CREATE DATABASE wordpress;

Next, create a user for WordPress:



CREATE USER 'wordpressuser'@'localhost' IDENTIFIED BY 'password';

Next, grant all privileges to the WordPress user:



GRANT ALL PRIVILEGES ON wordpress.* TO 'wordpressuser'@'localhost';

Next, flush the privileges:



FLUSH PRIVILEGES;

Next, exit the MySQL shell:



exit

Step 4 — Configure WordPress

To configure WordPress, run the following command:



sudo cp /var/www/html/wordpress/wp-config-sample.php /var/www/html/wordpress/wp-config.php

Next, open the WordPress configuration file:



sudo vi /var/www/html/wordpress/wp-config.php

Next, update the database name, user, and password:



/** The name of the database for WordPress */
define('DB_NAME', 'wordpress');
/** Database username */
define('DB_USER', 'wordpressuser');
/** Database password */
define('DB_PASSWORD', 'password');

Next, save and close the file.

Step 5 — Set Up WordPress

To set up WordPress, open your web browser and navigate to your domain name. For example, https://example.com.

Next, click on the Let’s go! button.

Next, enter the site title, username, password, and email address:

Next, click on the Install WordPress button.

Next, click on the Log In button.

Next, enter the username and password:

Next, click on the Log In button.

Now, you have successfully installed WordPress on Amazon Linux 2.

Note: Remember to protect your WordPress Admin Panel and cover up the URL and WordPress version.

Conclusion

In this tutorial, we learned how to install WordPress on Amazon Linux 2. We also discovered how to set up WordPress so that it functions with the Apache web server. We also discovered how to set up WordPress so that it functions with PHP and MariaDB.

Resources

How to Install PHP and MariaDB on Amazon Linux 2

Mohammad Abu Mattar — Sat, 03 Dec 2022 12:19:52 +0000

Introduction

We will learn how to set up PHP and MariaDB on Amazon Linux 2 in this tutorial. We will also discover how to set up PHP so that it functions with the Apache web server. We will also discover how to set up MariaDB so that it functions with PHP.

Prerequisites

To follow along with this tutorial, you will need:

An Amazon Linux 2 EC2 instance with a public IP address.
A non-root user with sudo privileges.
A domain name pointing to the public IP address of your EC2 instance.
Apache web server installed and running. How to Install Apache Web Server on Amazon Linux 2.

Installing PHP/MariaDB, setting up MariaDB, and running a basic PHP demo

Step 1 — Installing PHP

PHP is a free and open-source scripting language that is used to create dynamic web pages. It is the most popular web scripting language in the world.

At first, we will enable amazon-linux-extras so that we can specify the PHP version that we want to install.

sudo amazon-linux-extras enable php7.4 -y

Next, we will install PHP.

sudo yum install php php-{pear,cgi,common,curl,mbstring,gd,mysqlnd,gettext,bcmath,json,xml,fpm,intl,zip,imap} -y

We will now verify that PHP has been installed.

php -v

The output should look like this:

PHP 7.4.30 (cli) (built: Jun 23 2022 20:19:00) ( NTS )
Copyright (c) The PHP Group
Zend Engine v3.4.0, Copyright (c) Zend Technologies

Step 2 — Installing MariaDB

MariaDB is a free and open-source relational database management system (RDBMS) that is used to store data for dynamic web pages. It is a fork of MySQL.

At first, we will install MariaDB.

sudo yum install mariadb-server -y

Next, we will start MariaDB.

sudo systemctl start mariadb

We will configure MariaDB so that it starts automatically when the system boots.

sudo systemctl enable mariadb

We will now secure MariaDB.

sudo mysql_secure_installation

You will be prompted to enter the current root password for MariaDB. Press Enter to continue.

Enter current password for root (enter for none):

Next, you will be prompted to set a new root password for MariaDB. Enter a new password and press Enter.

Set root password? [Y/n]

You will be prompted to remove anonymous users. Press Y and then press Enter.

Remove anonymous users? [Y/n]

You will be prompted to disable remote root login. Press Y and then press Enter.

Disallow root login remotely? [Y/n]

You will be prompted to remove the test database and access to it. Press Y and then press Enter.

Remove test database and access to it? [Y/n]

You will be prompted to reload the privilege tables now. Press Y and then press Enter.

Reload privilege tables now? [Y/n]

Step 3 — Configuring PHP to Work with Apache

At first, we need to restart Apache.

sudo systemctl restart httpd

We will create a directory for our PHP files.

sudo mkdir /var/www/html/php

Next, we will create a PHP file.

sudo vi /var/www/html/php/index.php

We will add the following content to the file.

<?php
  phpinfo();

We will now open the file in a web browser.

http://your_domain_name/php/index.php

You should see the following output:

Step 4 — Configuring MariaDB to Work with PHP

At first, we will create a database for our PHP files.

sudo mysql -u root -p

CREATE DATABASE php;

Next, we will create a user for our PHP files.

CREATE USER 'php'@'localhost' IDENTIFIED BY 'password';

We will grant all privileges to the user.

GRANT ALL PRIVILEGES ON php.* TO 'php'@'localhost';

We will now exit MariaDB.

exit

We will create a PHP file.

sudo vi /var/www/html/php/db.php

We will add the following content to the file.

<?php
  $db = new mysqli('localhost', 'php', 'password', 'php');
  if ($db->connect_error) {
    die('Connection failed: ' . $db->connect_error);
  }
  echo 'Connected successfully';

We will now open the file in a web browser.

http://your_domain_name/php/db.php

You should see the following output:

Conclusion

In this tutorial, we learned how to set up PHP and MariaDB on Amazon Linux 2. We also learned how to set up PHP so that it functions with the Apache web server. We also learned how to set up MariaDB so that it functions with PHP.

Resources

How to Install Apache Web Server on Amazon Linux 2

Mohammad Abu Mattar — Sat, 03 Dec 2022 12:15:52 +0000

Introduction

In this tutorial, we will learn how to install Apache web server on Amazon Linux 2. We will also learn how to configure Apache web server to run simple HTML web page.

Prerequisites

To follow this tutorial, you will need:

An Amazon Linux 2 EC2 instance.
A user with sudo privileges.

Install Apache Web Server and run simple HTML web page

Step 1: Install Apache Web Server

Before we start, we need to update the package list and upgrade the installed packages:



sudo yum update -y

Now, we can install Apache web server:



sudo yum install httpd -y

Step 2: Start Apache Web Server

Now, we can start Apache web server:

Start Apache Server



sudo systemctl start httpd

Configure Apache to run on system boot



sudo systemctl enable httpd

Step 3: Configure Firewall

Now, we need to configure the firewall to allow HTTP traffic:



sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --reload

Step 4: Create a Simple HTML Web Page

Before we can test Apache web server, we need to change the permissions of the /var/www/html directory:



sudo chmod 777 /var/www/html

Now, we can create a simple HTML web page:



sudo vi /var/www/html/index.html



<!DOCTYPE html>

<html>

  <head>

    <title>Apache Web Server</title>

  </head>

  <body>

    <h1>Apache Web Server</h1>

    <p>This is a simple HTML web page.</p>

  </body>

</html>

Step 5: Test Apache Web Server

Now, we can test Apache web server by opening the public IP address of our Amazon Linux 2 EC2 instance in a web browser:

Conclusion

In this tutorial, we learned how to install Apache web server on Amazon Linux 2. We also learned how to configure Apache web server to run simple HTML web page.

References

Git SSH Keys for GitHub, GitLab, and Bitbucket on Linux

Mohammad Abu Mattar — Fri, 02 Dec 2022 14:29:41 +0000

Introduction

Git connects to remotes by default via HTTPS, which requires you to enter your login and password every time you run a command like Git pull or git push, using the SSH protocol. You may connect to servers and authenticate to access their services. The three services listed allow Git to connect through SSH rather than HTTPS. Using public-key encryption eliminates the need to type a login and password for each Git command.

Make sure a Git and SSH client is installed

A Git and SSH client must be installed on your system to connect via the SSH protocol. It should be installed by default if you use Arch Linux-based distributions like Manjaro or Garuda Linux.

git --version
ssh -V

That command should return the Git version adn SSH client's version number:

git version 2.34.1
OpenSSH_8.8p1, OpenSSL 1.1.1l  24 Aug 2021

If the system tells you that the ssh or git commands are missing, use the following command to install them:

Arch-based Linux systems:

sudo pacman -Syu
sudo pacman -Syyu
sudo pacman -S git
sudo pacman -S openssh

Debian-based Linux systems:

sudo apt update
sudo apt upgrade
sudo apt install git
sudo apt install openssh

Red Hat-based Linux systems:

sudo yum upgrade
sudo yum install git
sudo yum install openssh

Suse-based Linux systems:

sudo zypper upgrade
sudo zypper install git
sudo zypper install openssh

Fedora-based Linux systems:

sudo dnf upgrade
sudo dnf install git
sudo dnf install openssh

Don't forget to specify global Git settings using the following command after installing git:

git config --global user.name 'USERNAME'
git config --global user.email 'YOUR_EMAIL@EXAMPLE.COM'

Look for any SSH keys that have already been created

ls -lah ~/.ssh

The contents of the ~/.ssh folder, where the SSH client stores its configuration files, should be listed by that command:

Don't worry if you get an error saying there is no /.ssh directory or no files in there: it just indicates you haven't established an SSH key pair yet. Proceed to the next subject if this is the case.

It is advised that you produce a fresh SSH key pair at least once a year for security reasons. It is advised that you go on to the following topic if you already have an SSH key pair that was established more than a year ago. You can skip the following subject if you already have an SSH key pair and wish to reuse it.

Make a fresh set of SSH keys

Run the following command (change your YOUR_EMAIL@EXAMPLE.COM with your email address) to establish a new SSH key pair:

ssh-keygen -t rsa -b 4096 -C "YOUR_EMAIL@EXAMPLE.COM"
Generating public/private rsa key pair. Enter file in which to save the key (/home/your_user_name/.ssh/id_rsa):

It will ask you where you want to save the private key (id rsa), and you may accept the default location by pressing Enter.

Whether you already have a private key, it will ask if you want to override it:

/home/your_user_name/.ssh/id_rsa already exists.
Overwrite (y/n)?

If this happens, hit Enter and type y. Then, enter and re-enter the following passcode (think of it as a password):

Enter passphrase (empty for no passphrase):
Enter same passphrase again:

The SSH key pair is created in ~/.ssh, and the whole interaction should look like this:

your_user_name@your_host_name:~> ssh-keygen -t rsa -b 4096 -C "YOUR_EMAIL@EXAMPLE.COM"
Generating public/private rsa key pair.
Enter file in which to save the key (/home/YOUR_USER_NAME/.ssh/id_rsa):
/home/YOUR_USER_NAME/.ssh/id_rsa already exists.
Overwrite (y/n)? y
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/YOUR_USER_NAME/.ssh/id_rsa.
Your public key has been saved in /home/YOUR_USER_NAME/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:XenY8FOQmvIsjKVp6oAlITe3k1aMKRdViOFePP6/CuK YOUR_EMAIL@EXAMPLE.COM
The key's randomart image is:
+---[RSA 4096]----+
|o.=@X++.         |
|o*@O++           |
|=Bo+=+           |
|Oo+ oo..         |
|=+ . .. S        |
|...   o          |
| .   o .         |
|    . . o        |
|   E   . o.      |
+----[SHA256]-----+
YOUR_USER_NAME@YOUR_HOST_NAME:~>

To the ssh-agent, add your private SSH key

If you don't want to input your password every time you use your SSH keys, add it to the ssh-agent, which is a background application that saves your keys in memory while you're signed in to the system.

Run the following commands to start the ssh-agent in the background:

eval "$(ssh-agent -s)"

The ssh-agent process identification is returned by this command:

Agent pid 2887

Then, in the ssh-agent, add your SSH private key:

ssh-add ~/.ssh/id_rsa

Press Enter once you've typed your password:

Enter passphrase for /home/YOUR_USER_NAME/.ssh/id_rsa:

The ssh-agent has been updated with the private SSH key, according to this command:

Identity added: /home/YOUR_USER_NAME/.ssh/id_rsa (YOUR_EMAIL@EXAMPLE.COM)

To your account, add the public SSH key

You can connect through SSH after you have an SSH key and have added it to the ssh-agent. Let's take a look at how to implement it with each of the three servers: GitHub, GitLab, and Bitbucket.

The procedure is the same in all three circumstances, xclip is a command-line tool that gives you access to the clipboard in the graphical user interface from the terminal. If it isn't already installed, perform the following commands to do so:

Arch-based Linux systems:

sudo pacman -Syu
sudo pacman -Syyu
sudo pacman -S xclip

Debian-based Linux systems:

sudo apt update
sudo apt upgrade
sudo apt install xclip

Red Hat-based Linux systems:

sudo yum upgrade
sudo yum install xclip

Suse-based Linux systems:

sudo zypper upgrade
sudo zypper install xclip

Fedora-based Linux systems:

sudo dnf upgrade
sudo dnf install xclip

Using the xclip command, copy the contents of your public SSH key (/.ssh/id rsa.pub) file to the clipboard:

xclip -sel clip < ~/.ssh/id_rsa.pub

GitHub

Sign in to your GitHub account using a browser by going to github.com and entering your username and password. Click your profile photo in the upper-right corner of the page, then Settings:

Select SSH and GPG keys from the user settings sidebar. Then select New SSH key from the drop-down menu. Put a descriptive label for the new key in the Title area (for example, your computer's name) and paste your public key into the Key field. Last but not least, click Add SSH key:

The key is now visible in the list of SSH keys linked to your account:

GitLab

Sign in to your GitLab account using a browser by going to gitlab.com and entering your username and password. Click your profile photo in the upper-right corner of the page, then Settings:

Click SSH Keys in the User Settings sidebar. In the Key area, paste your public key. Fill in the Title area for the new key with a descriptive term (for example, the name of your computer). Finally, click the Add key:

The key is now visible in the list of SSH keys linked to your account:

Bitbucket

Log in to your Bitbucket account using a browser by going to bitbucket.org and entering your username and password. Click your profile photo in the lower-left corner of the website, then Bitbucket settings:

SSH keys may be found in the Settings sidebar's Security section. After that, select Add key from the drop-down menu. Fill up the Description box with a descriptive label for the new key (such as your computer's name), and then paste your public key into the Key field. Last but not least, choose to Add key:

The key has now been added to your account's list of SSH keys:

Test connecting via SSH

Before utilizing SSH with Git, GitHub, GitLab, and Bitbucket allow you to verify whether the connection has been set up successfully.

GitHub Test Connecting via SSH

Open the terminal once you've added your SSH key to your GitHub account and type:

ssh -T git@github.com

If you're connecting to GitHub over SSH for the first time, the SSH client will ask if you trust the GitHub server's public key:

The authenticity of host 'github.com (140.82.113.4)' can't be established.
RSA key fingerprint is SHA256:a5d6c20b1790b4c144b9d26c9b201bbee3797aa010f2701c09c1b3a6262d2c02.
Are you sure you want to continue connecting (yes/no)?

Press Enter after typing yes. GitHub has been added to the list of trustworthy hosts in the SSH client:

Warning: Permanently added 'github.com,140.82.113.4' (RSA) to the list of known hosts.

You won't be asked about GitHub's public key again once you've added it to the list of known hosts.

The server notifies you that you have successfully authenticated and ends the connection: Because this remote access through SSH is offered by GitHub only for testing purposes and not for practical usage, the server informs you that you have successfully authenticated and terminates the connection:

Hi YOUR_USER_NAME! You've successfully authenticated, but GitHub does not provide shell access.

If you passed the test, you may now utilize SSH with GitHub.

The entire interaction should look something like this:

ssh -T git@github.com

The authenticity of host 'github.com (140.82.113.4)' can't be established.
RSA key fingerprint is SHA256:a5d6c20b1790b4c144b9d26c9b201bbee3797aa010f2701c09c1b3a6262d2c02.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'github.com,140.82.113.4' (RSA) to the list of known hosts.
Hi your_user_name! You've successfully authenticated, but GitHub does not provide shell access.
YOUR_USER_NAME@YOUR_HOST_NAME:~>

GitLab Test Connecting via SSH

The test is pretty similar if you've added your SSH key to your GitLab account:

ssh -T git@gitlab.com

The authenticity of host 'gitlab.com (35.231.145.151)' can't be established.
ECDSA key fingerprint is SHA256:4ac7a7fd4296d5e6267c9188346375ff78f6097a802e83c0feaf25277c9e70cc.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'gitlab.com,35.231.145.151' (ECDSA) to the list of known hosts.
Welcome to GitLab, @YOUR_USER_NAME!

If you passed the test, you may now utilize SSH with GitLab.

Bitbucket Test Connecting via SSH

The test is pretty similar if you've added your SSH key to your Bitbucket account:

ssh -T git@bitbucket.org

The authenticity of host 'bitbucket.org (104.192.143.1)' can't be established.
RSA key fingerprint is SHA256:fb7d37d5497c43f73325e0a98638cac8dda3b01a8c31f4ee11e2e953c19e0252.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'bitbucket.org,104.192.143.1' (RSA) to the list of known hosts.
logged in as YOUR_USER_NAME.

You can use git or hg to connect to Bitbucket. Shell access is disabled.

If you passed the test, you may now utilize SSH with Bitbucket.

References

Git SSH Keys for GitHub, GitLab, and Bitbucket on Windows

Mohammad Abu Mattar — Fri, 02 Dec 2022 14:24:57 +0000

Introduction

Make sure a Git is installed

Make sure Git is installed before you start. Run the following command in your Windows terminal to see if Git is installed on your computer:

git --version

Install Git

To install Git, you can download the latest version from the official Git website. You can also install Git using Chocolatey or Winget package manager.

Install Git official website

To install Git from the official website, follow the steps below:

Go to the official Git website and download the latest version of Git for Windows.
Run the installer and follow the steps below:
1. Click Next on the first two screens to accept the default options.
2. Click Next on the Select Components screen.
3. Click Next on the Choosing the default editor used by Git screen.
4. Click Next on the Choosing the default terminal emulator screen.
5. Select the Use Git from the Windows Command Prompt option.
6. Select the Checkout Windows-style, commit Unix-style line endings option.
7. Select the Use Windows' default console window option.
8. Click Next on the Configuring the line ending conversions screen.
9. Click Next on the Configuring the terminal emulator to use with Git Bash screen.
10. Click Install on the Choosing HTTPS transport backend screen.
11. Click Finish on the Completing the Git Setup screen.
Open a new command prompt window and verify that Git is installed correctly by typing git --version.

Install Git using Chocolatey

To install Git using Chocolatey, follow the steps below:

Open Windows Terminal.
Run the following command to install Git:

choco install git -y

Verify that Git is installed correctly by typing git --version.

Install Git using Winget

To install Git using Winget, follow the steps below:

Open Windows Terminal.
Run the following command to install Git:

winget install --id=Git.Git  -e

Verify that Git is installed correctly by typing git --version.

Note: Don’t forget to specify global Git settings using the following command after installing git:

git config --global user.name 'USERNAME'
git config --global user.email 'YOUR_EMAIL@EXAMPLE.COM'

Generate SSH keys

To generate SSH keys, follow the steps below:

Open Windows Terminal.
Run the following command (change your YOUR_EMAIL@EXAMPLE.COM with your email address) to establish a new SSH key pair:

ssh-keygen -t rsa -b 4096 -C "YOUR_EMAIL@EXAMPLE.COM"

It will ask you where you want to save the private key (id rsa), and you may accept the default location by pressing Enter.

Whether you already have a private key, it will ask if you want to override it:

Overwrite (y/n)?

If this happens, hit Enter and type y. Then, enter and re-enter the following passcode (think of it as a password):

Enter a file in which to save the key (/c/Users/you/.ssh/id_rsa): [Press enter]

Enter a secure passphrase.

Enter passphrase (empty for no passphrase): [Type a passphrase]
Enter same passphrase again: [Type passphrase again]

The SSH key pair is created in ~/.ssh, and the whole interaction should look like this:

Verify that the SSH key was created by running the following command:

ls .\.ssh\

Add SSH key to the ssh-agent to your account

Copy the SSH key to your clipboard by running the following command:

Get-Content .\.ssh\id_rsa.pub | Set-Clipboard

GitHub

Sign in to your GitHub account using a browser by going to github.com and entering your username and password. Click your profile photo in the upper-right corner of the page, then Settings:

The key is now visible in the list of SSH keys linked to your account:

GitLab

Sign in to your GitLab account using a browser by going to gitlab.com and entering your username and password. Click your profile photo in the upper-right corner of the page, then Settings:

The key is now visible in the list of SSH keys linked to your account:

Bitbucket

The key has now been added to your account's list of SSH keys:

Test connecting via SSH

Before utilizing SSH with Git, GitHub, GitLab, and Bitbucket allow you to verify whether the connection has been set up successfully.

GitHub Test Connecting via SSH

Open the terminal once you've added your SSH key to your GitHub account and type:

ssh -T git@github.com

If you're connecting to GitHub over SSH for the first time, the SSH client will ask if you trust the GitHub server's public key:

The authenticity of host 'github.com (140.82.113.4)' can't be established.
RSA key fingerprint is SHA256:a5d6c20b1790b4c144b9d26c9b201bbee3797aa010f2701c09c1b3a6262d2c02.
Are you sure you want to continue connecting (yes/no)?

Press Enter after typing yes. GitHub has been added to the list of trustworthy hosts in the SSH client:

Warning: Permanently added 'github.com,140.82.113.4' (RSA) to the list of known hosts.

You won't be asked about GitHub's public key again once you've added it to the list of known hosts.

Hi YOUR_USER_NAME! You've successfully authenticated, but GitHub does not provide shell access.

If you passed the test, you may now utilize SSH with GitHub.

The entire interaction should look something like this:

ssh -T git@github.com

The authenticity of host 'github.com (140.82.113.4)' can't be established.
RSA key fingerprint is SHA256:a5d6c20b1790b4c144b9d26c9b201bbee3797aa010f2701c09c1b3a6262d2c02.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'github.com,140.82.113.4' (RSA) to the list of known hosts.
Hi your_user_name! You've successfully authenticated, but GitHub does not provide shell access.
YOUR_USER_NAME@YOUR_HOST_NAME:~>

GitLab Test Connecting via SSH

The test is pretty similar if you've added your SSH key to your GitLab account:

ssh -T git@gitlab.com

The authenticity of host 'gitlab.com (35.231.145.151)' can't be established.
ECDSA key fingerprint is SHA256:4ac7a7fd4296d5e6267c9188346375ff78f6097a802e83c0feaf25277c9e70cc.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'gitlab.com,35.231.145.151' (ECDSA) to the list of known hosts.
Welcome to GitLab, @YOUR_USER_NAME!

If you passed the test, you may now utilize SSH with GitLab.

Bitbucket Test Connecting via SSH

The test is pretty similar if you've added your SSH key to your Bitbucket account:

ssh -T git@bitbucket.org

The authenticity of host 'bitbucket.org (104.192.143.1)' can't be established.
RSA key fingerprint is SHA256:fb7d37d5497c43f73325e0a98638cac8dda3b01a8c31f4ee11e2e953c19e0252.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added 'bitbucket.org,104.192.143.1' (RSA) to the list of known hosts.
logged in as YOUR_USER_NAME.

You can use git or hg to connect to Bitbucket. Shell access is disabled.

If you passed the test, you may now utilize SSH with Bitbucket.

References

How To Create A Custom VPC Using AWS CLI

Mohammad Abu Mattar — Fri, 02 Dec 2022 14:16:30 +0000

Introduction

In the sample that follows, an IPv4 CIDR block, a public subnet, and a private subnet are all created using AWS CLI instructions. You can run an instance in the public subnet and connect to it once the VPC and subnets have been configured. Additionally, you may start an instance on the private subnet and link to it from the instance on the public network.

Prerequisites

AWS CLI
AWS Account

Configure AWS CLI: `aws configure`

# Configure AWS CLI

aws configure

#AWS Access Key ID [None]: # Enter your access key here
#AWS Secret Access Key [None]: # Enter your secret key here
#Default region name [None]: # Enter your region here
#Default output format [None]: # Enter your output format here

Create a VPC

# Get help for aws commands

aws help

# aws [COMMAND] [SUB-COMMAND] help

aws ec2 create-vpc help

# Create a VPC

AWS_VPC_INFO=$(aws ec2 create-vpc \
--cidr-block 10.0.0.0/16 \
--query 'Vpc.{VpcId:VpcId}' \
--output text)

Modify your custom VPC and enable DNS hostname support

# Modify your custom VPC and enable DNS hostname support

aws ec2 modify-vpc-attribute \
--vpc-id $AWS_VPC_INFO \
--enable-dns-hostnames "{\"Value\":true}"

Create a public subnet

# Create a public subnet

AWS_SUBNET_PUBLIC=$(aws ec2 create-subnet \
--vpc-id $AWS_VPC_INFO --cidr-block 10.0.1.0/24 \
--availability-zone us-east-1a --query 'Subnet.{SubnetId:SubnetId}' \
--output text)

Enable Auto-assign Public IP on the subnet

# Enable Auto-assign Public IP on the subnet

aws ec2 modify-subnet-attribute \
--subnet-id $AWS_SUBNET_PUBLIC \
--map-public-ip-on-launch

Create an Internet Gateway

# Create an Internet Gateway

AWS_INTERNET_GATEWAY=$(aws ec2 create-internet-gateway \
--query 'InternetGateway.{InternetGatewayId:InternetGatewayId}' \
--output text)

Attach the Internet gateway to your VPC

# Attach the Internet gateway to your VPC

aws ec2 attach-internet-gateway \
--vpc-id $AWS_VPC_INFO \
--internet-gateway-id $AWS_INTERNET_GATEWAY

Create a custom route table

# Create a custom route table

AWS_CUSTOM_ROUTE_TABLE=$(aws ec2 create-route-table \
--vpc-id $AWS_VPC_INFO \
--query 'RouteTable.{RouteTableId:RouteTableId}' \
--output text )

Associate the subnet with route table, making it a public subnet

# Associate the subnet with route table, making it a public subnet

AWS_ROUTE_TABLE_ASSOCITATION=$(aws ec2 associate-route-table  \
--subnet-id $AWS_SUBNET_PUBLIC \
--route-table-id $AWS_CUSTOM_ROUTE_TABLE \
--output text)

Get security group ID’s

# Get security group ID’s

AWS_DEFAULT_SECURITY_GROUP=$(aws ec2 describe-security-groups \
--filters "Name=vpc-id,Values=$AWS_VPC_INFO" \
--query 'SecurityGroups[?GroupName == `default`].GroupId' \
--output text)

AWS_CUSTOM_SECURITY_GROUP=$(aws ec2 describe-security-groups \
--filters "Name=vpc-id,Values=$AWS_VPC_INFO" \
--query 'SecurityGroups[?GroupName == `vpc-cli-lab-security-group`].GroupId' \
--output text)

Add tags to the resources in your VPC

# Add tags to the resources in your VPC

# Add a tag to the VPC

aws ec2 create-tags \
--resources $AWS_VPC_INFO \
--tags "Key=Name,Value=vpc-cli-lab"

# Add a tag to public subnet

aws ec2 create-tags \
--resources $AWS_SUBNET_PUBLIC \
--tags "Key=Name,Value=vpc-cli-lab-public-subnet"

# Add a tag to the Internet-Gateway

aws ec2 create-tags \
--resources $AWS_INTERNET_GATEWAY \
--tags "Key=Name,Value=vpc-cli-lab-internet-gateway"

# Add a tag to the default route table

AWS_DEFAULT_ROUTE_TABLE=$(aws ec2 describe-route-tables \
--filters "Name=vpc-id,Values=$AWS_VPC_INFO" \
--query 'RouteTables[?Associations[0].Main != `flase`].RouteTableId' \
--output text)

aws ec2 create-tags \
--resources $AWS_DEFAULT_ROUTE_TABLE \
--tags "Key=Name,Value=vpc-cli-lab-default-route-table"

# Add a tag to the public route table

aws ec2 create-tags \
--resources $AWS_CUSTOM_ROUTE_TABLE \
--tags "Key=Name,Value=vpc-cli-lab-public-route-table"

# Add a tags to security groups

aws ec2 create-tags \
--resources $AWS_CUSTOM_SECURITY_GROUP \
--tags "Key=Name,Value=vpc-cli-lab-security-group"

aws ec2 create-tags \
--resources $AWS_DEFAULT_SECURITY_GROUP \
--tags "Key=Name,Value=vpc-cli-lab-default-security-group"