DEV Community: Adaeze Nnamdi-Udekwe

Gxcc

Adaeze Nnamdi-Udekwe — Sun, 28 Jul 2024 01:58:12 +0000

Vvb ccv xfv.

Hosting Your Company's landing page (static website) on Google Cloud Using HTTPS & HTTP With Azure DNS Zone record

Adaeze Nnamdi-Udekwe — Tue, 04 Jun 2024 14:16:21 +0000

Introduction

Imagine getting a job or being assigned a task in your organization, probably as a new intern to host the company's website on Google Cloud but you must use a load balancer to share network traffic appropriately and also secure it using an SSL certificate. Do you know how to do that? If not, let's walk through it together.

In today's digital environment, businesses of all sizes must manage cloud resources effectively and securely. Businesses depend more on cloud infrastructure, so grasping the fundamental ideas and resources is critical. This article aims to explain a few basic features of Google Cloud Platform (GCP) and offer a step-by-step tutorial for creating a landing page with GCP services and your domain name.

Definitions of important terms like landing pages, folders, projects, DNS zones, and static websites will be covered. After that, we'll go over the actual procedures for setting up a safe and orderly cloud environment. After reading this article, you should be able to deploy a static website on GCP using your domain name, manage access controls, and easily arrange cloud resources.

Definitions

Folders: For your cloud resources, you can set up an orderly and controllable structure that will guarantee effective access control, billing management, and compliance.

Projects: They offer a mechanism to enforce quotas, manage billing, restrict access, and hierarchically arrange resources. To manage your GCP environment effectively and securely, you must understand how to use projects.

DNS Zone: You can arrange and manage DNS records for your domain names with DNS Zones. They can be private for internal use only within your VPC networks, or public for access to the internet. These zones are yours to make and maintain, and you can add different kinds of DNS records as needed. For domain names to correctly resolve to their corresponding IP addresses and for other services, DNS zone management is essential.

Static Website: Google Cloud Storage makes it simple to host a static website on Google Cloud Platform. Benefits include GCP's performance, dependability, and scalability. For websites where content doesn't need to be dynamically generated or updated often, this method is perfect.

Landing Page: With Google Cloud Storage, a landing page on Google Cloud Platform can be hosted effectively. This strategy makes use of GCP's strong infrastructure to provide your audience with high-performance static content while emphasizing simplicity, speed, and security.

Steps

Step 1: Create folder, project & Permission grant to Cloud Developer

i. Log into the google console you created your company domain name. My own domain name for this project is adaezennamdi.me. You should have yours which should have been added to a record set on DNS Zone and also mapped on a name server.

ii. On your search in your console, search for manage resource and click on it. Click on create folder, then folder, and name it Landing Page. The Organization and Location should all be your website organization name then click create.

iii. Click on Create Project to create a project called landing page. The Organization should be your website organization name and the Location, click on browse and pick Landing Page. Go ahead and click Create.

It would be best if you had something like this below if you are following the steps.

iv. Grant permission to user (owner) gcpcloudadmin. I have created a cloud admin before. Go ahead and create yours and give the admin account owner permission because that is the account we are using to do this project. Click on the pencil icon and edit principal.

v. Click on Role>> Basic>>Owner. Click on save.

Step 2: Download the Source Code and Test

i. We will be using a source code gotten from a template here. Download any HTML template. I will be using this one.

ii. Open the downloaded file and unzip it. We will be using the folders and files in our bucket.

iii. Test the code with your vs code to see the way the website looks. Open the unzipped folder with VS Code and open it on the browser by clicking below it where it says go live from the image below.

This is what I have after going live to test the sourced codes.

Step 3: Create a Bucket with the Company's domain and upload web files

i. Verify your company domain name first with this link below (https://search.google.com/search-console?authuser=1). Input your domain name and click continue

ii. Copy the code for verification and follow the prompt written. After which, come back to verify and you will see something like this.

iii. When you click on go to property, you will see an overview of what the performance of your website will be when it is hosted and visited.

iv. Create a bucket using the company's root domain name which you verified from the previous step. Go back to your google console and search for cloud storage. Click on it and click bucket. You will be asked to pick a project. Click the landing page project we created earlier in Step 1.

v. Click on enable billing before you proceed else you would not be able to use any of the services or resources.

vi. If you do not have up to 3 projects attached to your billing account, it should work for you and look like this.

vii. In your search bar, search for IAM & Admin and click on it. Click on IAM then on Grant Access. For New Principal, put your organization name. Mine is adaezennamdi.me. For Role, type and click on Organization Policy Administrator. Then click Save.

viii. You would see the policy just like this against your organization. This policy will give you permission to grant all users public access to your bucket storage.

ix. Under IAM & Admin, click on Organization Policies by your left-hand side. In the filter search bar, type domain and pick constraints/iam.allowedPolicyMemberDomains.

x. For Policy source,pick overide parent's policy.

xi. For Rule, edit it to allow all. Click set policy.

xii. You should have something like this after setting the policy.

xiii. Go back to your bucket. On your created bucket, click the 3 vertical dots by your extreme right and click on edit access.

xiv. For New Principal, put allUsers. For Role, type and click on Storage Object Viewer. Then click Save. This is to make all users over the internet see your website. Click Save and you will be prompted with Allow public access. Click on it.

xv. Under your created bucket, upload all the files of the template you want to use, then the folders.

xvi. Click on your bucket name and then scroll down through the files and click on the 3 vertical lines on index.hmtl. Click on Copy Public URL. copy the link and paste on your browser.

xvii. Your URL should look like this but with your own bucket name. This is the website I hosted shown below. You will see that your URL is not customized to carry your domain name. We will work on that.

Step 4: Set up HTTPS Load Balancer with SSL Certificate)

i. On your google console, navigate to your load balancer page by searching for the service inside the console. If you are asked to enable API for Compute Engine, click the button.

ii. Click on create load balancer to start the process. Click on any of the create load balancer you see.

iii. For Type of load balancer,pick Application Load Balancer (HTTP/HTTPS),then click next. For Public facing or internal, pick Public facing (external) and click next. For Global or single region deployment, click Best for global workloads. Click next. For Load balancer generation, click Global external Application Load Balancer and then next. Click configure to Create load balancer.

iv. For load balancer name,call it landingpage-lb. Under Frontend configuration,name it landingpage-frontend. For protocol,pick HTTPS. For port,put 443. For Ip address, click on the drop-down and click create IP address. Name it landing-pub-ip and click Reserve.

v. Under certificate, click on create a new certificate.

vi. For name of certificate,let the name be landing-cert. For Create mode, click on Create Google-managed certificate. For Domains, input your domain name for the first one and add www to the domain name for the second domain name. Click on Create.

vii. Under Additional Certificates, let SSL Policy be GCP Default. Let HTTP/3 (QUIC) negotiation be left as default. Check the box Enable HTTP to HTTPS redirect and click done.

viii. For Backend configuration, click on the dropdown backend services & backend buckets and click create a backend bucket.

ix. For Backend bucket name, let it be landing-backend. For
Cloud Storage bucket click on browse. Select the bucket you create earlier on and click select.

x. For Cloud CDN, tick Enable Cloud CDN.For Client TTL, Default TTL, and Maximum TTL, leave them with the default value.Leave every other parameter as default and click create. Click OK on the next prompt you see.

xi. For Routing rules,leave everything as default. Click on Review and finalize and make sure everything is in order and then click create.

xii. You should see something like this with the green checkmarks. if someone is trying to visit your website,with the information below,the person will be redirected to https.

Step 5: Create a domain record in Azure DNS Zone

i. Click on the link called landingpage-lb from the image above. Copy the IP address there. You will go and map it in your DNS server where you created the domain name and mapped your txt record. In my case, I used Azure DNS zone. If you did this project, under step 5,number vi,where we added a record for Azure. You will add same for google too in same place. That is why I am using same account carrying my domain name to map A record and CNAME record. The image below is for A record

ii. If you used azure to map your own records,then go to your azure portal, navigate to DNS ZONE, then click on DNS Management and recordsets under it. Click on Add to add record set.

iii. Name can be empty or you use @, Type should be A-Address Record, IP address should be the IP address from your load balancer you created from earlier step under IP:Port. Leave everything else at default and click Add.

iv. We will add another record type called CNAME.Name should be www and Type should be CNAME record. Your domain name will automatically show as your alias. Then click Add.

V. It will be mapped to your domain name like this even if you don't add it, as long as you are doing it under the domain name record.

vi. Use a DNS Checker to see that your domain name propagates across the world and it shows the IP address you inputted in the A record.

vii. Do the same for CNAME records too.

viii. You should see this on the certificate page after some minutes. It would have provisioned.

ix. You will see your website if you use the CNAME record with www.your domain name, and if you input just your domain name, you will see your website.

x. When you are done, delete your resources like bucket storage, load balancer, and SSL certificate in your google console.

Conclusion

Multiple steps are involved in setting up and maintaining a landing page on Google Cloud Platform, all of which contribute to a stable and secure cloud environment. You can guarantee effective access control, billing, and compliance management through comprehension and application of GCP's resources, including Folders, Projects, and DNS Zones. Performance, dependability, and scalability are just a few advantages that make hosting a static website on GCP a great option for many businesses.

This detailed documented steps thoroughly explain how to create a GCP project, configure required permissions, confirm domain ownership, and launch a static webpage. By following these procedures, you can use GCP's robust infrastructure to provide your audience with high-performance static content and guarantee a smooth and effective experience.

I would love to know if you found this helpful and if you could try it out. Your likes and comments will go a long way in encouraging me to keep writing more. See you in my next article!

Hosting a Static Website with CloudFront and AWS S3

Adaeze Nnamdi-Udekwe — Mon, 13 May 2024 18:27:42 +0000

Overview

Create a static website on Amazon S3 bucket(private bucket) but with public read policy assigned, using cloud front for Content Delivery Network.

Introduction

If I were to get married again, I'd probably host our wedding invite and love story on an AWS S3 bucket and use an OAI (Origin Access Identity) in CloudFront to restrict access to the AWS S3 bucket if I wanted to invite you strictly by invitation.😉 Well, let us host a wedding invite in this project whose template I got here. You can use any of the templates from here too.

Amazon S3

Amazon Web Services (AWS) provides scalable, high-performance object storage with its Amazon S3 (Simple Storage Service) offering. A key element of Amazon S3 is an S3 bucket, which serves as a container for objects (files and the metadata that goes with them) in a flat namespace.

Static Website

Without any dynamic server-side processing, a static website is one that is made up of fixed, pre-built HTML, CSS, and JavaScript files that are sent straight to the user's web browser. This indicates that during a user's session, the content on the website remains unchanged regardless of user interactions or input from outside sources. Businesses and individuals looking for a quick, safe, and simple way to maintain an online presence for informative content, including landing pages, blogs, or portfolios, should consider using static websites.

Amazon CloudFront

A service offered by Amazon Web Services (AWS) is Amazon CloudFront, a content delivery network (CDN). Its goal is to provide high transfer speeds and minimal latency in content delivery to end consumers globally. Application data and both static and dynamic content can be delivered more quickly to users in various geographical locations when using CloudFront.
Employing Amazon CloudFront enables businesses to deliver their apps and content closer to end users, improving speed and availability and resulting in quicker load times and an improved user experience.

You can also set up Access Control with OAI (Origin Access Identity) to restrict direct access to the S3 bucket, allowing access only through CloudFront, which we are going to be using for this project.

Prerequisite

An AWS account
The files to upload for your static website.

Steps

Step 1: Create a Bucket on Amazon S3

i. Log into your AWS console and use the search bar to search for S3 and click on it.

ii. Click on create bucket so as to input your bucket name.

iii. Input a bucket name in the Bucket name with a unique name which has not been used before. Go ahead and untick Block all public access

iv. Scroll down and click the acknowledgment box.

iv. Leave every other thing as default and scroll down and click create bucket.

Step 2: Upload Website files to S3 Bucket

i. Click on the bucket name so you can upload your website files into the bucket.

ii. Click on upload and select the files from your local file storage. Do well not to upload the overall folder carrying the other folders. Upload the folders one after the other so it opens on your browser along the line. Make sure that index.html resides in the root directory of the bucket.

iii. Click on upload folders and upload your folders from there. You can upload a file if that is what you have.

iv. After uploading the folders from your local file storage, click on Upload.

v. Give it some time to populate and upload. You will eventually see a small green banner after a while to indicate that it was successful.

Step 3:Enable Static Website Hosting on S3 Bucket Created

i. Click on the close button and see all your files or folders. Click on the Properties tabs and scroll down to Static website hosting

ii. Click on Edit on Static website hosting

iii. Click on the radio button Enable. Under hosting type, click on Host a static website. Under Index document, type index.html in it.

iv. Leave every other thing as default and scroll down and click on save changes

Step 4 - Attach a Bucket Policy

i. Click on Permissions tab and scroll down to Bucket policy

ii. Click on Edit under Bucket policy to input your bucket poilicy to allow access the website on the S3 bucket.

iii. Attach the policy below and replace bucket name with your bucket name. Scroll down and click on save changes.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "PublicReadGetObject",
            "Effect": "Allow",
            "Principal": "*",
            "Action": "s3:GetObject",
            "Resource": "arn:aws:s3:::<bucket name>/*"
        }
    ]
}

iv. Click on the Properties tabs and scroll down to Static website hosting and copy the link there to open on your browser.

v. When you open it if you everything right, you should see the static website here. This is what mine looks like.

https://www.loom.com/share/752de16b21684e0aa3d04fbcbfa3a5d4?sid=3dacffd6-399b-4813-a268-e8d52a8bb145

Step 5 - Create a CloudFront Distribution to make your AWS S3 bucket private

i.Search for Cloudfront in your AWS console and click on it.

ii. Click on Create a CloudFront distribution and populate it.

iii. There is no existing Origin Access Control (OAC) so we need to create one. Click on Create new OAC

iii. Under Origin domain, input the url you used in opening the your website which is found in your created S3 bucket under Properties >> Static website hosting. If you see the use website endpoint in yours, do not click on it. If you do,you will not see the Origin access control settings which you need to set to make your bucket private.

iv. You should get a page like this. Leave everything as default especially the origin type as S3. Then click create

v. Under Web Application Firewall (WAF), click on the radio button Do not enable security protections. We just want to keep it simple.

vi Leave everything as default and click create distribution

vii. Click on create policy and click on the circled url to paste the policy.

viii. Navigate to permissions under your bucket and scroll to bucket policy and click edit. Delete the policy you pasted before which you used to see if your bucket was publicy accessible before we used cloudfront to make it private.Paste the copied policy in here. Scroll down and click on save changes. The policy can be found below also.

{
        "Version": "2008-10-17",
        "Id": "PolicyForCloudFrontPrivateContent",
        "Statement": [
            {
                "Sid": "AllowCloudFrontServicePrincipal",
                "Effect": "Allow",
                "Principal": {
                    "Service": "cloudfront.amazonaws.com"
                },
                "Action": "s3:GetObject",
                "Resource": "arn:aws:s3:::my-wedding-invitation/*",
                "Condition": {
                    "StringEquals": {
                      "AWS:SourceArn": "arn:aws:cloudfront::154334184944:distribution/E22OCAT2YCY14Z"
                    }
                }
            }
        ]
      }

ix. Navigate back to your cloudfront tab and copy the Distribution domain name. Paste it on your browser and add /index.html to it. i.e https://d3fvr8swd8au27.cloudfront.net/index.html Make sure to use your own Distribution domain name.

x. It would bring out your website page for you just like mine.

Conclusion

Based on the steps we have taken to achieve this, it can be implied that the tutorial describes how to set up a private static website with Amazon S3 and CloudFront. Enabling static website hosting with a public read policy and setting up an S3 bucket to store website files are among the procedures. For global access, fast transfer rates and minimal latency are therefore guaranteed by creating a CloudFront distribution for content delivery.

For the CloudFront distribution to control access to the S3 bucket, establishing an Origin Access Control (OAC) is an essential step in the procedure. To further make the S3 bucket private, the guide outlines how to remove the existing public read policy and change the bucket policy to limit access to only the CloudFront service.

The documentation concludes by showing you how to use CloudFront to enhance the security and performance of your static website hosted on S3, all the while keeping it private and only available via the CloudFront distribution.

PS: Please remember to disable and then delete your Cloudfront and also empty and delete your AWS S3 bucket so you avoid incurring costs.

Step-by-Step Guide: Setting Up Azure Entra ID with Domain Names and User Management

Adaeze Nnamdi-Udekwe — Mon, 06 May 2024 14:06:41 +0000

Introduction

What is Azure Entra ID?

Originally known as Azure Active Directory (Azure AD), Azure Entra ID is a cloud-based identity and access management service provided by Microsoft. Controlling user identities and granting access to cloud-based resources, services, and apps is made efficient and secure with its help. To help businesses enhance security and expedite user management in both on-premises and cloud environments, Azure Entra ID enables role-based access control, multifactor authentication, and single sign-on (SSO).

Now that we know what an Entra ID is, let's set up one!

Prerequisites

Azure portal
Azure Entra ID
Domain name
Credit card for billing(if you're opening the azure portal account for the first time)

Steps

Step 1: Create a Domain Name

i. Create a domain name with a domain name provider. Something simple and cheap. Below is my domain name which I created with Namecheap.

Step 2: Create an Email Address.

i. Create an email address for the purpose of this task especially if you have created an Azure portal before or not. A hotmail, outlook or gmail will do. For the purpose of this task, I created a new hotmail account,so you can do the same.

Step 3: Create an Azure Cloud Account.

i. Create an Azure cloud account with this link . You can get free 200 credits if you are creating the azure account for the first time else you will have to use the pay-as-you-go model to set up your subscription.

Step 4: Create a DNS Zone

i. In the Azure portal you just created, search for DNS Zone, and click on create or create DNS zone. Anyone will work.

A DNS zone is a resource that contains the DNS records for a specific domain, allowing you to manage the domain's DNS settings such as IP addresses and mail exchange servers.

ii. Under Project details, in Subscription, pick the subscription that is there by default. In Resource group, click on create new and put a name of your choice.

Under Instance details, in Name, put your domain name which you created in step 1. In resource group location I picked Canada East. Then click review create.

iii. You should see a page like this if you do everything properly. Click Create.

iv. You should see the image below.

v. Click on go to resources and see your DNS servers. I circled it for you to see.

Step 5: Configure Nameservers on NameCheap

i. If you used namecheap domain provider, then navigate to the Domain List at your left, and click on manage by your right.

ii. Scroll down and you will see the nameservers section. Click the dropdown circled and pick Custom DNS.

iv. From step 4, number v, copy all the nameservers circled and paste them on the namecheap nameserver lines, and press the green tick just above it to have them all saved.

Step 6: Create a Custom Domain

i. On a new tab, open the Entra ID link. Still, leave the Azure portal tab open as we will need it later.

ii. In the Entra ID, on the left side, navigate to identity >> settings >> domain names. Click on Add custom domain.

iii. Add the domain name you created in this project and click Add domain.

iv. Click on verify just below.

iv. Back to your Azure portal, click on Record set.

v. Copy the '@' in the Alias or hostname from the Entra ID tab and paste it in the Azure portal tab's Add record set name section.

vi. From the Enrta ID, the record type is 'TXT', pick it from the drop-down in the Azure portal.

v. The TTL in the Entra ID is 3600 seconds which is equivalent to 1 hour so pick 1 hour in the Azure portal.

vi. Copy the value under the Destination or points to address in Entra ID and paste it under value in the Azure portal. Click OK to create the record set.

vii. You will see the record created just like the one below.

viii. Go back to the Entra ID tab, and navigate to the custom domain names. We want to make our custom domain we created the primary domain. It is presently not the custom domain as the default one given to us by Azure is the primary domain.

ix. Click on your domain name and tick the place that says make primary. Whatever prompt you see, click 'Yes'.

x. If you go back to your custom domain and refresh the page, you will see that your custom domain is now the primary domain.

Step 7: Create single and bulk Users in Entra ID

i. Navigate to identity >> Users >> all users, click on create user drop down, and then click on create new user.

ii. input a name you want in the User principal name and display name . You can use the auto-generate password or you untick it and create your own. Click Review + Create and then click on create. Refresh your page and you will see your newly created user.

iii. To create the bulk users using the company's domain name, click on bulk operations dropdown and click bulk create.

iv. Click on 'download' and download the spreadsheet and populate it with data

v. It should look like what is below. Under the user name, let the names after the '@' be your domain name. Populate everything with names of your choice and then download the spreadsheet as a CSV file. The passwords can be changed by the users after they use their credentials to log in. They do not need to own the same passwords afterwards.

vi. Go back to the Entra ID page and then upload the downloaded file and then click submit.

v. Refresh the page and you will see all the users from the uploaded spreadsheet just like mine below.

Step 8: Assigning Roles and Groups.

i. Click on any user of your choice you want to assign a role to. We will be assigning an administrative (admin) role in this project. After clicking on any of the users, click on assigned roles and then add assignments

ii. Assign global administrator if you want the person to be in charge of the azure account and give an account of all that happens in it. It is not a role to assign to anyone anyhow. You can read the permissions the person has that I highlighted. Then go ahead and click add.

iii. Click on audit logs to see a list of activities happening in the administrative user's account.

iv. Go back to your users and then on the left side, navigate to identity >> groups >> All groups and then click on new group

v. Populate the spaces with what you want like I did mine below. Click on No owners selected and pick user of your choice and No members selected and select users to be members in that group. For the No owners selected, you are selecting who will be in charge of the group you've created. Click create. Refresh your page and you will see the group you created. Click on it and see an overview of all you did.

vi. This is what yours should look like when you are done creating the group and assigning owner and members to the group. Click on the group created. I have a total of 6 members and one owner. I added the owner as a member so they can have member privileges too.

Conclusion

To sum this up, this tutorial offered a comprehensive method for configuring and overseeing Azure Entra ID, encompassing the creation of domain names, email addresses, and DNS zones, in addition to setting up custom domains and handling users, roles, and groups. You can set up a safe and effective identity management system for your cloud environment by following these steps. With Azure Entra ID, you can improve security and streamline user management for both on-premises and cloud services.

Automation of LAMP (Linux, Apache, MySQL, PHP) stack deployment using Bash Script in Ansible

Adaeze Nnamdi-Udekwe — Sat, 27 Apr 2024 16:30:30 +0000

Introduction

A Bash Script is a text file with several commands written in the Bash shell language. The Bash shell carries out operations one by one when you run the script. This allows you to automate repetitive tasks, manage files, and configure systems.

Ansible is an open-source automation tool for configuration and
management of IT infrastructures. It allows for the easy
management of numerous servers using YAML language to describe
automated tasks. Ansible operates agentlessly, meaning there is no
need to install additional software on the nodes it manages.

You will appreciate the use of Ansible as a tool if you find out about things it does to make your IT job easy. Here are some advantages:

Ease of use and simplicity: YAML is a human-readable language used to write playbooks (configuration files).
Strong and adaptable: Ansible is capable of managing challenging jobs and changing with the times.
Agentless: Management and security are made simpler by not requiring software to be installed on the controlled nodes.
Idempotent: Playbooks can be run repeatedly without producing unpleasant or unexpected results.
Huge support and community: Ansible has a large and active community, as well as a wealth of modules and resources.

Context

Just so we understand what we are going to be doing in this project, I will explain all that it entails.

We are going to automate the provisioning of two Ubuntu-based servers, named “master” and “slave”, using Vagrant.
On the Master node, we will create a bash script to automate the deployment of a LAMP (Linux, Apache, MySQL, PHP) stack.
The bash script we create above should clone a PHP application from GitHub, install all necessary packages, and configure Apache web server and MySQL.
We will ensure the bash script is reusable and readable.
Using Ansible Playbook, we will execute the bash script on the Slave node and verify that the PHP application is accessible through the Virtual Machine’s IP address.
We will also create a cron job to check the server’s uptime every 12 am.

Steps

Setting Up Virtual Machines

To create a Virtual Machine, Check these resources for Ubuntu.
You should have a Vagrantfile for the Virtual Machines saved in your local file folder just like mine below after you start your machine. But if you don't I can walk you through it. Remember you need to create 2 Ubuntu servers named "master" and "slave". Open your Virtual box down as you will need it open to start your Virtual Machines. Create two folders and name them "master" and "slave".

Open the folders with Gitbash. Let us start with the "master" folder.

Next is to Initialize your master Ubuntu machine. After opening the "master" folder with git bash, run:

vagrant init Ubuntu/focal64

Open the Vagrantfile and make some edits to the configuration file using the command nano vagrantfile. It would help if you had something like this.

Go ahead to paste the configuration below just under Vagrant.configure("2") do |config| like the image below. Also, add config.ssh.insert_key = false under config.vm.box = ubuntu/focal64. Press "crtl+O" to save, then "enter" and "ctrl+x" to exit the vagrantfile.

# Provision master Node
config.vm.define "master" do |master|
master.vm.box = "ubuntu/focal64"
master.vm.hostname = "master"
master.vm.network "private_network", ip: "192.168.33.10", type: "dhcp"
end

NOTE: I have circled the aspects you should the various commands under. Pay attention to them.

Then run the following command to start the machine. It would be best if you had something like the image below towards the end after running the command.

vagrant up

Connect the virtual machine by running:

vagrant ssh

Now that you have logged into your "masters" virtual machine, follow the same procedure for the "slave" virtual machine. You should have something like the screenshot below by the time you ssh into your "slave" virtual machine.

NOTE: Every other thing is the same for the procedure except for the configuration in the vagrant file which should be under Vagrant.configure("2") do |config|. Use the command below under the Vagrant.configure("2") do |config|.

# Provision Slave Node
config.vm.define "slave" do |slave|
slave.vm.box = "ubuntu/focal64"
slave.vm.hostname = "slave"
slave.vm.network "private_network", ip: "192.168.33.11", type: "dhcp"
end

Connect the "master" and "slave" machine by _ssh-ing _into each of them

Use the command ip a to check for the IP address of each of the virtual machines. Below is that of the "master's" virtual machine. The circled one is the IP address for the "master" virtual machine. Do the same for the "slave" virtual machine. I have underlined each one for you to know what virtual machine owns each IP address. Also, note that your IP address will be different from mine.

On your "master" Virtual Machine, write ssh-keygen to generate a private & public key. When you run the command you will see Enter file in which to save the key (/home/vagrant/.ssh/id_rsa): Enter passphrase (empty for no passphrase): Enter same passphrase again: Keep pressing the "enter" key when those 3 lines appear as seen below.

We will repeat the above step for the "slave" virtual machine too and should look like what is below.

In the "master" virtual machine, change the directory into ssh with the command cd .ssh and then ls to list all the files in the ssh directory. You will see something like what is below.

Open the content of id_rsa.pub and copy it to save it somewhere for later use. That is where your public key is and that is what you are copying. Use this command to open it cat id_rsa.pub. The key would be long and look like something below.

Change the directory to .ssh with the command cd .ssh just as we did in the "master" virtual machine. Create and open a file in the .ssh directory of the "slave" machine at once so that the public key you copied from the "masters" machine and saved somewhere, you will paste it in the created file. I named my file 'public'. Run the command nano public and paste the public key from the "master" virtual machine here. After pasting all the public keys correctly, press 'crtl+O' to save, press 'enter', and then press 'ctrl+X' to exit.
Then run the command cat public >> authorized_keys to copy the public keys into the authorized_keys file from the file named public in the "slave" machine. Run the command cat authorized_keys to see the content of the copied public keys of the "masters" virtual machine and the "slave" virtual machine. Below is an image of both the "masters" and "slave" public keys.

Connect the "master" virtual machine to the "slave" virtual machine by using ssh to connect the IP address of the "slave" machine to the "master" machine. First of all, run the command ip a to know the IP addresses in each machine. Then run the command ssh vagrant@slave ip in the "master" virtual machine. It should look like this ssh vagrant@192.168.33.9 Make sure to replace the IP address with your own "slave" IP address. Whatever it prompts you, type 'yes'. From the screenshot, you can see that we can connect to our "slave" machine from the "master" machine.

Creating the Bash Script and Ansible to automate the provisioning of the two Ubuntu-based Virtual Machines we've created.

In your "master" virtual machine, create your script that will automate the deployment of LAMP (Linux, Apache, MySQL, PHP) stack.
Name your script anything of your choice with the .sh extension. I will be naming mine LAMP.sh. Use the command touch LAMP.sh to create your script. run ls to see if the script file you ran is showing.

Run nano LAMP.sh to open the file script and write your script. Please copy and paste this script inside it. Each line of the command has a comment with a brief explanation with a '#' symbol in front of it. I made sure to pick each line of commands one by one to run before compiling it into a full script below.

#!/bin/bash

# Define variables for paths and IP address
LARAVEL_DIR="/var/www/html/laravel"
LARAVEL_CONF="/etc/apache2/sites-available/laravel.conf"
VIRTUAL_HOST="192.168.33.9"

# Update all package index and upgrade packages
sudo apt update
sudo apt upgrade -y
echo "Done with upgrade package"

# Update the PHP repository
sudo add-apt-repository -y ppa:ondrej/php
echo "Done with php repo update"

# Install Apache
sudo apt install -y apache2
sudo systemctl enable apache2
echo "Done with Apache installation"

# Install MySQL
sudo debconf-set-selections <<< 'mysql-server mysql-server/root_password password'
sudo debconf-set-selections <<< 'mysql-server mysql-server/root_password_again password'
sudo apt install -y mysql-server
echo "Done with MySQL installation"

# Install PHP 8.2 and 8.3 with necessary extensions
sudo apt install -y php libapache2-mod-php php-mysql php8.2 php8.2-curl php8.2-dom php8.2-xml php8.2-mysql php8.2-sqlite3 php8.3 php8.3-curl php8.3-dom php8.3-xml php8.3-mysql php8.3-sqlite3
echo "Done with PHP 8.2 and 8.3 installation"

# Run MySQL secure installation
expect <<EOF
spawn sudo mysql_secure_installation
expect "Would you like to setup VALIDATE PASSWORD component?"
send "y\r"
expect {
    "Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG" {
        send "1\r"
        exp_continue
    }
    "Remove anonymous users?" {
        send "y\r"
        exp_continue
    }
    "Disallow root login remotely?" {
        send "n\r"
        exp_continue
    }
    "Remove test database and access to it?" {
        send "y\r"
        exp_continue
    }
    "Reload privilege tables now?" {
        send "y\r"
        exp_continue
    }
}
EOF
echo "Done with MySQL secure installation"

# Restart Apache
sudo systemctl restart apache2
echo "Done with Apache restart"

# Install Git
sudo apt install -y git
echo "Done with Git installation"

# Clone Laravel repository
sudo git clone https://github.com/laravel/laravel $LARAVEL_DIR
echo "Done with cloning Laravel repository"

# Change directory to Laravel folder
cd $LARAVEL_DIR
echo "Changed directory to $LARAVEL_DIR"

# Install Composer
sudo apt install -y composer
echo "Done with installing Composer"

# Upgrade Composer to version 2
sudo php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
sudo php -r "if (hash_file('sha384', 'composer-setup.php') === 'dac665fdc30fdd8ec78b38b9800061b4150413ff2e3b6f88543c636f7cd84f6db9189d43a81e5503cda447da73c7e5b6') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
sudo php composer-setup.php --install-dir /usr/bin --filename composer
echo "Done with upgrading Composer to version 2"

# Use Composer to install dependencies
yes | sudo composer install
echo "Done installing Composer dependencies"

# Copy Laravel configuration file and set permissions
sudo cp .env.example .env
sudo chown www-data:www-data .env
sudo chmod 640 .env
echo "Done copying Laravel configuration file and setting permissions"

# Create virtual host in /etc/apache2/sites-available
sudo tee $LARAVEL_CONF >/dev/null <<EOF
<VirtualHost *:80>
    ServerName $VIRTUAL_HOST
    ServerAlias *
    DocumentRoot $LARAVEL_DIR/public

    <Directory $LARAVEL_DIR>
        AllowOverride All
    </Directory>
</VirtualHost>
EOF
echo "Done creating virtual host in /etc/apache2"

# Generate application key
sudo php artisan key:generate
echo "Done generating application key"

# Run migrations
sudo php artisan migrate --force
echo "Done running migrations"

# Change ownership permissions
sudo chown -R www-data:www-data $LARAVEL_DIR/database/ $LARAVEL_DIR/storage/logs/ $LARAVEL_DIR/storage $LARAVEL_DIR/bootstrap/cache
echo "Done changing ownership permissions"

# Set file permissions
sudo chmod -R 775 $LARAVEL_DIR/database/ $LARAVEL_DIR/storage/logs/ $LARAVEL_DIR/storage
echo "Done setting file permissions"

# Disable default configuration file
sudo a2dissite 000-default.conf
echo "Done disabling default configuration file"

# Enable Laravel configuration file
sudo a2ensite laravel.conf
echo "Done enabling Laravel configuration file"

# Restart Apache
sudo systemctl restart apache2
echo "Done restarting Apache"


uptime > /var/log/uptime.log

Press 'crtl+O' to save, press 'enter' and then 'crtl+X' to exit the script.

The variables created in the first three lines of the script allow for its reusability, as mentioned in our context.

Leave the repository as it is in the script, as it is the same one linked earlier in this article.

Here is a snippet of my script

Below are detailed explanations of what each line of command does:

i. Defining variables for paths and IP address:

-LARAVEL_DIR="/var/www/html/laravel": This variable specifies the directory where the Laravel application will be located.

-LARAVEL_CONF="/etc/apache2/sites-available/laravel.conf": This variable specifies the path for the Apache virtual host configuration file for Laravel.

-VIRTUAL_HOST="192.168.33.9": This variable specifies the IP address for the virtual host.
ii. Updating package index and upgrading packages:

-sudo apt update: Updates the list of available packages and their versions.
-sudo apt upgrade -y: Upgrades all installed packages to the latest versions. The -y option automatically answers "yes" to prompts.
iii. Updating the PHP repository:

-sudo add-apt-repository -y ppa:ondrej/php: Adds the PHP PPA (Personal Package Archive) maintained by Ondřej Surý, which provides the latest PHP versions.

iv. Installing Apache:

sudo apt install -y apache2: Installs the Apache web server.
sudo systemctl enable apache2: Enables Apache to start automatically on system boot.

v. Installing MySQL:

sudo debconf-set-selections <<< 'mysql-server mysql-server/root_password password': Configures the root password for MySQL server installation.
sudo apt install -y mysql-server: Installs the MySQL server.

vi. Installing PHP 8.2 and 8.3 with necessary extensions:

sudo apt install -y php libapache2-mod-php php-mysql php8.2 ...: Installs PHP 8.2 and 8.3 with necessary extensions such as curl, dom, xml, mysql, and sqlite3.

vii. Running MySQL secure installation:

The expect block automates the mysql_secure_installation process, answering prompts automatically to set up MySQL securely.

viii. Restarting Apache:

sudo systemctl restart apache2: Restarts the Apache web server.

ix. Installing Git:

sudo apt install -y git: Installs Git, a version control system.

x. Cloning Laravel repository:

sudo git clone https://github.com/laravel/laravel $LARAVEL_DIR: Clones the Laravel repository from GitHub to the specified directory.

xi. Changing directory to Laravel folder:

cd $LARAVEL_DIR: Changes the current working directory to the Laravel folder.

xii. Installing Composer:

sudo apt install -y composer: Installs Composer, a dependency management tool for PHP.

xiii. Upgrading Composer to version 2:

These commands download and verify the Composer installer, then install Composer version 2.

xiv. Installing Composer dependencies:

yes | sudo composer install: Installs Composer dependencies for the Laravel project, automatically answering "yes" to prompts.

xv. Copying Laravel configuration file and setting permissions:

Copies the Laravel .env.example configuration file to .env and sets appropriate ownership and permissions.

xvi. Creating virtual host in /etc/apache2/sites-available:

sudo tee $LARAVEL_CONF >/dev/null <<EOF: Creates a new virtual host configuration file for Laravel.
This block of code sets up the virtual host with the specified server name, alias, and document root.

xvii. Generating application key:

sudo php artisan key:generate: Generates a unique application key for the Laravel project.

xviii. Running migrations:

sudo php artisan migrate --force: Runs database migrations for the Laravel project.

xix. Changing ownership permissions:

sudo chown -R www-data:www-data $LARAVEL_DIR/...: Changes ownership of specified directories to the www-data user and group.

xx. Setting file permissions:

sudo chmod -R 775 $LARAVEL_DIR/...: Sets file permissions to 775 (read, write, execute for owner and group; read and execute for others).

xxi. Disabling default configuration file:

sudo a2dissite 000-default.conf: Disables the default Apache configuration file.

xxii. Enabling Laravel configuration file:

sudo a2ensite laravel.conf: Enables the Laravel virtual host configuration file.

xxiii. Restarting Apache:

sudo systemctl restart apache2: Restarts the Apache web server to apply changes.
xxiv. Logging system uptime:
uptime > /var/log/uptime.log: Records the current system uptime to a log file.
Test run the script to see if it works by running the command ./LAMP.sh

Still in your "master" machine create an Ansible directory with the command

mkdir Ansible

Change into the Ansible directory so it becomes your present working directory.

cd Ansible

Run this command to update any dependencies. From the image below, you should have something like the image below at the end after the update.

sudo apt-get update

Then to install Ansible run the command below. It would be best if you had something like the image at the end of the installation.

sudo apt install ansible

Still, in your Ansible directory, create your inventory. The inventory file is used to store the address of the slave nodes to be configured which will enable the playbook to run in the "slave" machine even if it is created in the "master's" machine.

touch inventory

Open your inventory file to put in the IP address of your "slave" machine. It should look like the image below, but use your IP address. Press 'crtl+O' to save, press 'enter', and then 'crtl+X' to exit the text editor.

Create your playbook with the .yml extension.

touch playbook.yml

To ping your inventory run the command in your "master" machine. It should look like the screenshot below. Press 'crtl+C' to cancel it afterwards.

ansible all -m ping -i inventory

Change the directory back to Ansible with the command cd Ansible. Then open the playbook with the command nano playbook.yml. Paste the command below inside your playbook but change the IP address to your "slave" machine IP. Press 'crtl+O' to save, press 'enter', and then 'crtl+X' to exit the playbook.

---

- hosts: slave
  become: yes
  tasks:

    # Copy LAMP.sh script to the slave node
    - name: Copy LAMP.sh script to slave node
      copy:
        src: /home/vagrant/Ansible/LAMP.sh
        dest: /home/vagrant/LAMP.sh
        mode: 0755  

      # Make the script executable

    # Execute the LAMP.sh script on the slave node
    - name: Execute LAMP.sh script on slave node
      shell: /home/vagrant/LAMP.sh


- name: Create a cron job to check server's uptime every 12 am
  hosts: slave
  become: yes
  tasks:

    # Create an uptime script that logs the server's uptime to a file
    - name: Create the uptime script
      copy:
        content: |

          #!/bin/bash

          # Log the server's uptime to a file
          uptime > /var/log/uptime.log
        dest: /usr/local/bin/check_uptime.sh
        mode: '0755'  # Make the script executable

    # Create a cron job that runs the uptime script every day at 12 am (midnight)

    - name: Create a cron job to check uptime every 12 am
      cron:
        name: Check uptime every 12 am
        job: "/usr/local/bin/check_uptime.sh"

        # Run at 12:00 am
        minute: '0'  
        hour: '0'
        state: present

    # Display the contents of the uptime log file
    - name: Display uptime log file
      shell: cat /var/log/uptime.log
      register: uptime_output

    # Display the server's uptime as captured in the uptime log file
    - name: Display the server's uptime
      debug:
        msg: "{{ uptime_output.stdout }}"

    # Task to fetch the content of the PHP application using curl
    - name: Fetch PHP application content using curl
      command: "curl -s http://192.168.33.9"  # Perform a silent HTTP GET request to the target IP address
      register: php_application  # Register the output of the curl command
      ignore_errors: true  # Continue playbook execution even if this task fails

    # Task to display the content fetched from the PHP application
    - name: Display content of PHP application
      debug:
        msg: "PHP Application Content:\n{{ php_application.stdout }}"  # Display the output of the curl command

Here is a snippet of my playbook

Created a cron job to check the server’s uptime every 12 am in my playbook. You can find the task in the playbook above but this is a snippet of it.

This is the content of my log file where the server's uptime check is stored. Since my master and my slave are connected, I was able to check this from my "slave" machine. I used the command sudo crontab -l to check.

Run the command below to execute the playbook:

ansible-playbook playbook.yml -i inventory

I could execute the bash script on the Slave node and verify that the PHP application is accessible through the VM’s IP address. I have circled the slave IP address in the screenshot.

Paste your "slave" IP address on your web browser. This is the output with the slave IP address. A Laravel PHP application.

Conclusion

In summary, one of the effective and dependable methods for provisioning and controlling servers has been demonstrated in this project by the automation of the LAMP (Linux, Apache, MySQL, PHP) stack deployment utilizing a Bash script in Ansible. The deployment of the LAMP stack on Ubuntu-based servers is quite fast and less labor-intensive than with manual setup because of the script automation and it is even reusable.

The Bash script can be easily adapted to many environments and use cases due to its reusability, which is attained through defining variables that can be passed as parameters and error handling.

The deployment process was further automated and made uniform and repeatable by integrating the script into an Ansible playbook. In addition to establishing cron jobs to track server uptime and confirming that PHP applications could be accessed, the playbook carried out actions on both the master and slave nodes, giving important information about server performance.

Even though there were a few difficulties along the road, like script errors and log file problems, these could be fixed with thorough debugging and code modifications. The result showed that the PHP application was successfully deployed and verified on the slave node's IP address.

All things considered, the project demonstrates how Ansible and Bash scripting can be used to automate intricate deployment procedures. This detailed documentation of the stages and solutions makes it useful for future deployments and projects utilizing the LAMP stack.

Linux Commands (Trying Out Linux commands with Directories and Files)

Adaeze Nnamdi-Udekwe — Sun, 24 Mar 2024 23:00:00 +0000

Linux Commands

"So what is Linux? Can you explain to me like I am 5 years old?"

Ps: I'll be using folders and directory interchangeably but they mean the same thing

Suppose you own a large box filled with vibrant building blocks. These blocks have incredible power! They can construct robots, cars, planes, even houses. Linux can be thought of as a unique collection of instructions that explains how to use these blocks for play.

Now imagine that you want to use your building pieces to create a cool robot. Linux makes things easier for you by demonstrating exactly which blocks to use and how to combine them. It identifies the bricks that make up the robot's limbs, legs, eyes, and even brain!

However, Linux isn't limited to robot construction. It can also assist you in creating other enjoyable things out of your blocks, such as building a spaceship to travel across space or a fantastical palace to house your toys.

Thus, Linux may be thought of as a useful manual that demonstrates how to utilize your basic building blocks to create a plethora of beautiful things and have a great time!

Linux is an open-source operating system developed by Linus Torvalds. It is an operating system just like Windows and MacOS.

I want to walk you through an exercise where you get to use linux commands to walk around especially if this is your first time. Try it and let me know how it goes!

EXERCISE

Create your login name and name it anything. I name mine altschool i.e., home directory /home/altschool. The home directory contains the following sub-directories: code, tests, personal, misc Unless otherwise specified, you are running commands from the home directory.

I will share each step with commands needed to run in the terminal. They will be embedded inline codes.

i. Create a login name called Altschool on your terminal from your root user. You can use vagrant virtual machine or gitbash

sudo useradd -Ums /bin/bash Altschool

useradd command helps you create a new login user

-Ums

U flag creates user and assign a group with same name as the user.

m flag creates the home directory.

s flag specifies the default login shell

ii. Switch user from vagrant (root user) to Altschool user created

sudo su Altschool

sudo is the command that allows regular users to perform administrative tasks or commands that typically require root or superuser privileges

su allows you to switch to a different user account from the command line, including the root or superuser account.

iii. create sub directories named code, tests, personal & misc

mkdir code tests personal misc

Use ls to check that the list of the directories created are in the home directory.

mkdir means make directory. It is a command in Linux for creating new directories or folders to organize your files and data.

ls means list. This is used to display a list of files and directories in the current directory or a specified directory.

Instructions:

Just before we get to the exercise, let us discuss the difference between Home Directory (cd /home) and Root Directory (cd /).

The home directory is a directory connected to each user account, holding personal files and configurations unique to that user, while the root directory is the top level directory in the file system hierarchy which houses the necessary system files.

a.Change directory to the tests directory using absolute pathname

cd /home/Altschool/tests

cd means change directory. It is a command that is used to move to another directory. Like changing from the present directory to another existing directory of your choice

Absolute pathname specifies the location of a file or directory from the root directory of the file system. It provides the complete path starting from the root directory and includes all intermediate directories. For example, in a Unix-like file system, an absolute pathname might look like /home/Altschool/tests, where the first "/" after the "cd" command represents the root directory. Think of it like giving directions starting from the very bottom of the tree, the roots. So, if we want to find something, we start from the roots and follow the path all the way up to the branch where it's stored

b. Change directory to the tests directory using relative pathname

cd ./tests

When you wish to refer to files or directories in relation to where you currently are in the filesystem hierarchy, relative pathnames come in handy just like cd ./tests. They are frequently more practical and shorter than absolute pathnames. It describes the path from the current directory. For example, if the current directory is /home/Altschool/, a relative pathname to access the file tests located in the Altschool directory would be "cd tests" or "cd ./tests" where the first "." after the "cd" means you want to search in the present folder and the "/tests" is the folder you want to change to, particularly for moving across directories that share a structure. But if you change the current working directory, they could become unclear.

The same relative pathname may correspond to multiple files or directories depending on where you are in the filesystem because relative pathnames are interpreted based on the current working directory.

c. Use echo command to create a file named fileA with text content ‘Hello A’ in the misc directory. (remember we are doing everything along each step in the home directory of Altschool user)

echo 'Hello A' > misc/fileA

echo command is used for printing text or variables to the terminal or into a file in the terminal. One cool thing I love about the echo command is that you can print into a new file on one line of command, redirecting the output of a command into a new file using the ">" symbol. The file does not necessarily have to be created before you can print in it. I hope that is clear. Check the attached image for context.

Also, since we are creating and using all commands in the home directory of Altschool, we will have to echo into misc/fileA following the path of misc.

Then use the ls command (I already explained it previously) with the -al flag to check for ALL directories, files, and everything in that directory. You can always have a directory inside a directory. A directory is synonymous to a folder.

d. Create an empty file named fileB in the misc directory. Populate the file with a dummy content afterwards

touch misc/fileB to create the fileB

nano misc/fileB to write in a dummy content in the fileB

cat misc/fileB to check the content in the fileB

touch command is used to create files.

nano is a text editor that is commonly used for quick edits, viewing configuration files, or making simple changes to text files in Linux environments. It's especially popular on servers or systems without graphical user interfaces (GUIs) where command-line tools are preferred. One down side of this command is that your mouse won't function on the screen while in the text editor. The use of arrow keys and alphabet keys on the keyboard Allows you to do the job of writing and editing text on the screen.

cat is a "concatenate"command. It is a versatile and handy tool for quickly viewing the contents of files in the terminal after writing inside the file.

e. Copy contents of fileA into fileC

cp misc/fileA misc/fileC

cp command as it literally mean is to copy content from a file to another file while retaining contents and the file the initial copy was made from.

f. Move contents of fileB into fileD

mv misc/fileB misc/fileD

mv can be used to move contents of a file to another, and also directories. You can also use it to rename files and directory.This flexibly allows renaming files and directories as well as conviently moving contents from a former file to a new one .This implies that the old file from which the contents were moved from will cease to exist.

g. Create a tar archive called misc.tar for the contents of misc directory

tar -cvf misc.tar misc

the tar command offers a flexible and powerful way to archive and manage files and directories in Linux systems.

Then the -cvf flag will be broken into bits so it will enable me explain them better. The c flag is used to create archive. The v flag stands for "verbose." When used, tar will display detailed information about the files and directories being archived.The f flag stands for "file." It is used to specify the name of the archive file.

h. Compress the tar archive to create a misc.tar.gz file

gzip misc.tar

The gzip command is used for compressing files to save disk space or reduce transfer times when transferring files over a network.

i. Create a user and force the user to change his/her password upon login

sudo chage -d 0 praise

Remember I already explained what sudo is above right? So we would not touch it anymore.

When it comes to setting password expiration rules for user accounts on Linux systems, administrators have flexibility thanks to the chage command. Because administrators may tailor password aging policies to meet organizational needs, it helps enforce security best practices by guaranteeing that users update their passwords on a regular basis.

When a system administrator create a new user on the server of a company he/she creates the user with a password and the sends the details to that user to login ... To ensure the user's account is safe he/she(administrator) forces the user to change the password upon first login so that only the user has the new password

In the context of the chage command, the -d flag is used to set the date of the last password change for a user account. This flag allows the administrator to manually specify how many times the user should use the old password created by him/her(the administrator), and that is why we have 0 as it means the number of time a user can use the password before changing it. Apparantly, the user can only use the password the one time they used it in logging in.

j. Lock a users password

sudo passwd -l praise

The passwd command means password. and combined with the -l flag it is used to lock a user account. It prevents users from logging in. Locking user accounts is useful for temporarily preventing access to an account, such as during maintenance or investigation of security issues. It can also be used as a security measure if a user's access needs to be revoked temporarily or permanently.

k. Create a user with no login shell

sudo useradd -s /sbin/nologin Vicky

The -s /sbin/nologin command is used to set the login shell for a user account to /sbin/nologin. A user account configured with /sbin/nologin as its login shell will prevent interactive logins through Telnet, SSH, or other means. Rather, upon attempting to log in, the user will be met with an error message stating that login is prohibited, usually accompanied with an administrator-provided message. By preventing interactive logins, it helps enhance the security of the system by limiting potential points of unauthorized access.

The grep command is used to search contents of a file... in the command cat /etc/passed | grep username the "|" is a pipe symbol used to redirect the output of a command into another command which is the grep

l. Disable password based authentication for ssh

sudo vi /etc/ssh/sshd_config

The command vi /etc/ssh/sshd_config is used to open the SSH daemon configuration file (sshd_config) in the vi text editor,just like the nano text editor we talked about earlier.

Here's a breakdown of what each part of the command does:

vi: This is the command to invoke the vi text editor in the terminal. vi is a widely used text editor in Unix-like operating systems, including Linux.

/etc/ssh/sshd_config: This is the path to the SSH daemon configuration file. In most Linux distributions, SSH (Secure Shell) configuration files are stored in the /etc/ssh/ directory. The sshd_config file specifically contains configuration settings for the SSH daemon (sshd), which is the server-side component of the SSH protocol. This file controls various aspects of the SSH server's behavior, such as authentication methods, allowed users, permitted protocols, and more.

Therefore, when you run vi /etc/ssh/sshd_config, you are opening the sshd_config file in the vi text editor, allowing you to view and edit the configuration settings for the SSH daemon.

From the screenshot in line 47 PasswordAuthentication is set to 'no' which disables the password authentication for ssh.

m. Disable root login for ssh

vi /etc/ssh/sshd_config

As a continuation from the disabled authentication, scroll back up on the vi editor to line 29 where you have PermitRootLogin and set it to 'no' and save it. You save by pressing the esc key then the double colon (:) followed by the "wq" to save it then you press ENTER to leave the test editor. It should look like this :wq . There you go!

Conclusion:

In summary, as you navigate the terminal, embrace the learning process with patience and perseverance. Every error is a chance to deepen your understanding, and each solution adds to your expertise. Keep exploring, keep learning, and let your discoveries empower your Linux journey. Your thoughts, experiences, and feedback are valuable—feel free to share them with others in our vibrant community of learners. Together, we can inspire and support each other on this exciting adventure through the command line.

Install, Configure, and Host a Custom Website on Apache2 Web Server, with Ubuntu, Using AWS EC2 Instance

Adaeze Nnamdi-Udekwe — Fri, 22 Mar 2024 11:26:16 +0000

Introduction

Ubuntu provides the foundation and infrastructure necessary to run web server software like Apache2, enabling it to serve web content to clients over the internet.

We will be covering Installing, Configuring, and Hosting a Custom Website on Apache2 Web Server, with Ubuntu, Using AWS EC2 Instance.

What you will need for this Hands-on

•AWS management console

•AWS EC2 Instance (free tier) . You can check the pricing list here if you do not have a free-tier account

•GitHub account

Setting up of EC2 Instance

Log into your AWS management console to begin this hands-on. Navigate to the EC2 instance by searching for the service in the console and click on it so you can create an instance. Click on 'launch instance'. I have marked it in a rectangular shape. Please take note of every area I emphasized with a circle or rectangle in the course of explaining this project.
After clicking on the 'launch instance', name your instance and then proceed to pick your Operating system (AMI) as Ubuntu. Make sure it is the free trier just like my screenshot so you do not incur costs while trying to set up.
Proceed to create a key pair or use an existing key pair like I did. The key pair is used for secure SSH (Secure Shell) access to the instance. Scroll down to the security group and allow SSH traffic and HTTP traffic. I am emphasizing this because when I attempted this task severally, I kept getting errors when I tried to load my Apache2 on my web. This was because I did not allow for HTTP in my security group. No way that was going to work because enabling HTTP in your security group is crucial for ensuring that your web server can effectively communicate with clients and provide access to your online content and services in a secure and efficient manner. Go ahead to launch your instance.
After the instance created shows the running state, click on the check box, then proceed to click on connect.
Go ahead to "connect using the Instance Connect". Click on the orange button saying "Connect". You will be taken to a terminal.

Installing Apache2

One of the most extensively used open-source web servers in the world is Apache2, sometimes known as Apache HTTP Server or just Apache. The internet can receive web content thanks to Apache2. It is a well-liked option for hosting websites and web applications because of its great versatility, scalability, and customization. Web apps and dynamic websites are frequently made with Apache2. It is a reliable option for companies, organizations, and site hosts all around the world.

Steps:

Run the command sudo apt update on your terminal to check for new updates. It should look like what is in the screenshot below.
Proceed to install Apache by running sudo apt install apache2 command. You will see "Do you want to continue? [Y/n]". Type Y and press enter on your keyboard. You should see something like what is in the screenshot below. Copy the circled Public IP address and run it on your browser.
Boom! You should have this page on your web after running your own unique Public IP address. Your IP address is not expected to look like mine. You would have your own unique address.

Hosting Custom Website on Apache2 Web Server.

Install git on your terminal first by running this command sudo apt install git. You should have something like what is in the screenshot below. We are installing git so that we use it to clone some codes from my GitHub repository that we will use as our custom website. You can go ahead and click on the link and use it for this demonstration.
Create a folder next and name it whatever you want using the command mkdir 'foldername' , for example mkdir adaeze . This is the folder we will be putting our cloned git repository. Change your directory to the new folder created using the cd command. Something like cd adaeze since 'adaeze' is the directory/folder I created.
Get any git repository with codes for a website or you can use mine. In the repository, click on the circled part that says 'code' colored green. Then copy to the clipboard using the button I circled as number 2.
Go back to your terminal to clone the repository. the git clone command is an essential tool for getting a local copy of a remote
Git repository. So it should look like this git clone https://github.com/Adaeze-69/Alt-School-Assignment-3.git
Change the directory into the cloned repository. The command to run is cd Alt-School-Assignment-3/ .This is the directory where all
your codes are found. Your HTML and CSS codes you cloned. Remember that this directory is inside the 'adaeze' directory which has
been your present working directory (pwd). See the screenshot below to understand better.
1. Run ls command to see the list of files in the cloned directory.
1. Create another directory that will host your website. It should be like this: sudo mkdir /var/www/newfilefolder . Mine looks like this: sudo mkdir /var/www/adaezennamdi .
2. Next is to copy the content of everything in the present directory that you are. For me, /adaeze/Alt-School-Assignment-3 is my present working directory, just like the screenshot. The '*' is called a wild card which copies everything in that directory.
1. Next is to cd into the new file folder you created and ls to be sure all the contents you copied are present there.
1. Create a new 'conf' file with the command touch where you will move the default conf file into
1. Copy the contents of everything in the default conf file into the newly created 'conf' file which in my case is 'adaezennamdi.conf'. It should look like this sudo cp /etc/apache2/sites-available/000-default.conf /etc/apache2/sites- available/adaezennamdi.conf.
1. Go ahead to edit the new 'conf' file you created using the command sudo nano /etc/apache2/sites-available/adaezennamdi.conf
1. When you get into the nano editor, scroll down to DocumentRoot. Where you see 'adaezennamdi', you will see 'html'. Delete the 'html' and write the new name you gave to your folder you created in the /var/www/foldername. Mine is 'adaezennamdi' and that is why you see it there. After that, press 'ctrl O' on your keyboard to save, press the 'Enter' key, and then 'ctrl X' to exit the editor.
1. Enable your created custom new conf file with the command sudo a2ensite adaezennamdi.conf. Please, remember to use your own 'conf file' name you created and not mine.
1. Disable the 'default conf file' 000-default.conf whose contents were copied. The command should look like this sudo a2dissite 000-default.conf . If you do not disable this, your site will not load because this will still be running. Disabling it is necessary as this process will allow your enabled "Conf" from the previous steps to run efficiently.
1. At this point, you will need to reload your apache2 web server. To do that, type sudo systemctl reload apache2 into your terminal.
1. On your web browser, revisit the Apache2 web server page (refer to step 4), process to reload it, and confirm if you have a similar snapshot with the image below (the image will be exact if you cloned my repository).
1. Remember to terminate your AWS EC2 instance when you get to this point. Do not stop it but terminate. If you stop it, you will still incur costs from the Elastic Block Storage (EBS) Volume running with it. Terminate the EC2 instance. From the screenshots below, tick the checkbox, then click on the drop-down 'instance state' . You will see 'Terminate instance'. Click on it to redirect you to the page on the second screenshot. Click on 'Terminate' that is circled, and that is all.

Conclusion

Congratulations on completing the guide to Installing, Configuring, and Hosting a Custom Website on Apache2 Web Server, with Ubuntu, Using AWS EC2 Instance. While the process may have been challenging, your perseverance paid off. Remember, if you encounter challenges, seek help from documentation or online resources. You can also reach out to me on this platform too.

I hope you found value in this article and enjoyed the journey as much as I did creating it. Your dedication enriches our community. Keep exploring and innovating. Here's to your continued success!

Feel free to share your feedback and experiences. Best wishes on your future endeavors!