DEV Community: Victoria Oludamilola Oyewole

WRITING A CONFIGURATION FILE FOR AWS(EC2 CONSOLE) USING TERRAFORM

Victoria Oludamilola Oyewole — Sat, 07 Mar 2026 08:47:24 +0000

** WHAT IS TERRAFORM?**

Terraform is an infrastructure-as-code tool that lets you build, change, and version cloud and on-premises resources safely and efficiently.

HashiCorp Terraform is an infrastructure-as-code tool that lets you define both cloud and on-premises resources in human-readable configuration files that you can version, reuse, and share. You can then use a consistent workflow to provision and manage all of your infrastructure throughout its lifecycle. Terraform can manage low-level components like compute, storage, and networking resources, as well as high-level components like DNS entries and SaaS features. It is widely considered the industry standard for cloud provisioning due to its ability to manage various services (AWS, Azure, GCP, Kubernetes, etc.) with a single, consistent workflow.

                      Key Concepts

Declarative Language (HCL): Unlike imperative tools that require you to script step-by-step instructions, Terraform uses HashiCorp Configuration Language to describe the desired end state of your infrastructure. You tell Terraform, "I want a virtual machine," and it determines how to create it.

Providers: These are plugins that allow Terraform to interact with cloud providers (AWS, Azure, GCP), SaaS services, and other APIs.

Resources: The individual infrastructure components defined in configuration files, such as virtual machines, storage buckets, or network security groups.

State (terraform tf state)**: Terraform creates a state file that maps your configuration to real-world resources. This acts as a "source of truth" to track changes, manage dependencies, and detect configuration drift.
Modules: Reusable containers for multiple resources used together, allowing for standardized, shareable code (e.g., a standard web server module)

                **   The Core Workflow**

Terraform follows a simple, repeatable three-stage workflow:

Write: Define resources in .tf configuration files.

Plan (terraform plan): Terraform compares the desired state to the current state (via the state file) and creates an execution plan, showing what it will create, update, or destroy.

Apply (terraform apply): Upon approval, Terraform executes the plan, interacting with APIs to bring the infrastructure to the desired state.

STEPS ON CONFIGURATION AND IMPLEMENTATION OF TERRAFORM ON YOUR COMPUTER AND THE CONFIGURATION FILE FOR EC2 CONSOLE.

Terraform is an open-source tool that allows you to define cloud resources in human-readable configuration files. This is called 'Infrastructure as Code'.

Implementation Guide

Install Terraform

Set up your local environment for Infrastructure as Code (IaC).

(a) Install on Windows (using Chocolatey if you are window user)

$ choco install terraform

(b) Verify Installation

_ $ terraform --version_

Before writing code, you need a playground. Creating a directory keeps your state files and configurations separated from other projects.

2 Prepare Project Directory

Organize your Terraform files in a dedicated workspace.

(a) Create & Enter Folder

📘Instruction Summary

This creates a clean workspace for your infrastructure code.

_ $ mkdir my-terraform-lab_
Creates a new directory (folder).

$ cd my-terraform-lab
Changes the current directory.

3.Write Provider Config

Connect Terraform to your Cloud Provider.

The 'provider' block tells Terraform which cloud you want to talk to (AWS, Azure, GCP, etc.). It acts as a translator between your code and the cloud's API.

(a) Create main.tf

📘Instruction Summary

Add a file named main.tf in your project folder and paste the provider block.

Note: This is the 'Provider Block'. It tells Terraform we are targeting AWS in the US East region.

(b) Initialize Terraform

Initializes Terraform — downloads provider plugins and sets up the backend where state is stored.

This command downloads the AWS provider plugin into your project folder. Note the new terraform directory.

** Declare Resource**

Define what you want to build in the cloud.

Key Concept

The 'resource' block describes a specific piece of infrastructure, like a Virtual Machine (VM) or a Storage Bucket.

(a) Add a Resource Block

📘 Instruction Summary

Append this to your main.tf file.

resource "aws_instance" "my_server" {
ami = "ami-0c7217cdde317cfec"
instance_type = "t2.micro"

tags = {
Name = "SkillSchTerraformLab"
}
}

(b) Preview Your Changes

$ terraform plan

Shows a preview of what Terraform will create, change, or destroy — always review this before applying.

This shows you exactly what Terraform is about to create before it actually does it.

Apply Changes

Actually deploy your infrastructure to the live cloud.

Key Concept

Running 'apply' makes the changes real. Terraform will reach out to the cloud API and create the resources.

(a) Deploy to Cloud

_ terraform apply_

Applies the planned changes to create or update your infrastructure. You'll be prompted to confirm.

Type 'yes' when prompted to confirm the deployment.

(b) ** Check Your State**

📘Instruction Summary

This command shows you the current state of your live infrastructure.

terraform show

Displays the current state or a saved plan in a human-readable format.

(6) ** Manage State & Backends**

Understand how Terraform tracks your infrastructure.

Terraform uses a 'state' file to keep track of what it built. For teams, we store this in a 'backend' like S3 or Azure Blob Storage.

(a) View Local State

📘Instruction Summary

Notice the local file created after your 'apply'.

ls terraform.tfstate

💡 Lists files and directories. -l shows details (permissions, size, date).

(b) Learn about Remotes

📘Instruction Summary

In a real job, you'll move this to a remote cloud storage bucket so your teammates don't overwrite your work.

(7) ** Clean Up & Share**

Destroy resources and push your code to GitHub.

(a) Destroy Everything

📘Instruction Summary

Always destroy your lab resources to keep your cloud bill at zero

terraform destroy

💡 Tears down all infrastructure managed by this Terraform config — use for cleanup.

(b) Push to Portfolio

git init

💡 Initializes a new Git repository in the current directory.

git add .

💡 Stages all changed files for the next commit.

git commit -m 'feat: terraform infrastructure lab'

💡 Creates a new commit with all staged changes and the message after -m.

git push origin main

💡 Uploads your local commits to the remote repository.

[Boost]

Victoria Oludamilola Oyewole — Fri, 03 Oct 2025 20:58:13 +0000

A Guide on how to run a Complete CI/CD Pipeline with Node.js, Docker, and Kubernetes.

Victoria Oludamilola Oyewole ・ Oct 3

#beginners #tutorial #devops #node

A Guide on how to run a Complete CI/CD Pipeline with Node.js, Docker, and Kubernetes.

Victoria Oludamilola Oyewole — Fri, 03 Oct 2025 20:29:30 +0000

DevOps Model Defined.

DevOps is the combination of cultural philosophies, practices, and tools that increases an organization’s ability to deliver applications and services at high velocity: evolving and improving products at a faster pace than organizations using traditional software development and infrastructure management processes. This speed enables organizations to better serve their customers and compete more effectively in the market.

Also, DevOps can be best explained as people working together to conceive, build and deliver secure software at top speed. DevOps practices enable software development (dev) and operations (ops) teams to accelerate delivery through automation, collaboration, fast feedback, and iterative improvement. Stemming from an Agile approach to software development, a DevOps process expands on the cross-functional approach of building and shipping applications in a faster and more iterative manner.

In adopting a DevOps development process, you are making a decision to improve the flow and value delivery of your application by encouraging a more collaborative environment at all stages of the development cycle. DevOps represents a change in mindset for IT culture. In building on top of Agile, lean practices, and systems theory, DevOps focuses on incremental development and rapid delivery of software. Success relies on the ability to create a culture of accountability, improved collaboration, empathy, and joint responsibility for business outcomes.

***CORE DEVOPS PRINCIPLES*
Automation of the software development lifecycle**. This includes automating testing, builds, releases, the provisioning of development environments, and other manual tasks that can slow down or introduce human error into the software delivery process.

** Collaboration and communication**. A good DevOps team has automation, but a great DevOps team also has effective collaboration and communication.

Continuous improvement and minimization of waste. From automating repetitive tasks to watching performance metrics for ways to reduce release times or mean-time-to-recovery, high performing DevOps teams are regularly looking for areas that could be improved.
**
Hyperfocus on user needs with short feedback loops**. Through automation, improved communication and collaboration, and continuous improvement, DevOps teams can take a moment and focus on what real users really want, and how to give it to them.
By adopting these principles, organizations can improve code quality, achieve a faster time to market, and engage in better application planning.

However, having a niche of what DevOps is about, we dive into the practical aspect of how to run a Complete CI/CD Pipeline with Node.js, Docker, and Kubernetes, breaking down into steps on how to use the tools to achieve an application.

Before starting, you need to install these tools on your machine:

Required Downloads:

Node.js (v18 or higher) - Current LTS: v20.x

Download from: https://nodejs.org/
Choose the LTS version (20.x as of 2025)
Verify installation: node --version and npm --version

Git - Latest stable version

Download from: https://git-scm.com/downloads
Choose your operating system version
Verify installation: git --version

Docker Desktop - Latest version

Download from: https://www.docker.com/products/docker-desktop/
Install and start Docker Desktop
Verify installation: docker --version and docker-compose --version

GitHub Account

Code Editor (Optional but recommended)

VS Code: https://code.visualstudio.com/
Or any editor you prefer (Sublime Text, Atom, etc.)

Verify Everything is Installed
node --version # Should show v18.x+ or v20.x+
npm --version # Should show 9.x+ or 10.x+
git --version # Should show 2.34+
docker --version # Should show 24.x+

The above shows that all application to be used for the project are installed.

The Procedure:

_Step 1 Creation of a Folder for the work or project you are about to do. Select File and Click on the icon Open folder, it will take you the PC folder, give the new folder the name you want it to have.

Click on the View icon, you will have some lists of icon, click on Terminal

Step 1:1 Set Up Git for Version Control_

What this step does: Configures Git on your machine so it knows who you are when you make commits, and sets up proper project tracking.

One-time Git Configuration

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global init.defaultBranch main

The above shows my name and e-mail as the user.

Create and Initialize Project

mkdir new-devops-project that is, create a new project file.

cd new-devops-project

git init

The directory has been initialize by the use of git init command and it has turn to a repo although the file is still empty.

Step 2: Build a Node.js Web App

What this step does: Creates a web application using Node.js that can serve web pages and API endpoints.

Initialize Node.js Project

What this step does: Creates a package.json file that describes your project and manages dependencies.

Create package.json with default settings

npm init -y

In the image above, the default package json was created, it will be deleted because it is not the original file to be used, it will be replaced.

Below is the original file to be worked with.

Create Application File
What this code does:

Creates an HTTP server that listens on port 3000
Serves different endpoints (/, /health, /info, /metrics)
Includes security headers and proper error handling
Provides graceful shutdown capability
Exports the server for testing
Create app.js:

The code for the app.js created are shown below:

The Next Step after the main app.js file has been created, to make the code to run, we need what is called a' Dependencies".

Install Dependencies

Install testing and development tools

npm install --save-dev jest eslint supertest

Install all dependencies (creates node_modules folder)

npm install

What you'll see:

A node_modules/ folder with all installed packages
A package-lock.json file that locks dependency versions

Below is the folder called node_mouldes after the command npm install --save-dev jest eslint supertest has been ran. This holds the codes

Step 3: Create Proper Tests

What this step does: Sets up automated testing so you can verify your application works correctly every time you make changes.

Create tests directory and test file

Create a folder for your tests

mkdir tests

Create the main test file

touch tests/app.test.js

Create test file
Copy this code into tests/app.test.js: The code that was copied is shown below:

Create Jest configuration
Create jest.config.js:

Step 4: GitHub Actions CI/CD Pipeline

What this step does: Creates an automated pipeline that runs tests and builds Docker images every time you push code to GitHub.

Create workflow directory

Create the GitHub Actions directory structure

mkdir -p .github/workflows

Create CI/CD pipeline file
Create .github/workflows/ci.yml:

Step 5: Dockerfile

What this step does: Creates instructions for Docker to build a container image of your application that can run anywhere.

What this Dockerfile does:

Uses multi-stage builds for smaller image size

Installs curl for health checks.
Creates a non-root user for security.
Sets up proper file permissions.
Configures health checks.

Create Dockerfile:

Step 6: Essential Configuration Files

What this step does: Creates configuration files that tell various tools what to ignore, how to behave, and what settings to use.

Create .dockerignore

Create .dockerignore:

node_modules npm-debug.log* .git .github .env .env.local .env..local logs *.log coverage .nyc_output .vscode .idea *.swp *.swo .DS_Store Thumbs.db README.md tests/ jest.config.js .eslintrc

Create .gitignore

Create .gitignore:

Dependencies node_modules/ npm-debug.log* # Runtime data pids .pid .seed .pid.lock # Coverage coverage/ .nyc_output # Environment variables .env .env.local .env..local # Logs logs .log # IDE .vscode/ .idea/ .swp *.swo # OS .DS_Store Thumbs.db

Create environment template

Create .env.example:

Server Configuration PORT=3000 NODE_ENV=production # Logging LOG_LEVEL=info

Create ESLint configuration

Create .eslintrc.js:
module.exports = {
env: {
node: true,
es2021: true,
jest: true
},
extends: ['eslint:recommended'],
parserOptions: {
ecmaVersion: 12,
sourceType: 'module'
},
rules: {
'no-console': 'off',
'no-unused-vars': ['error', { 'argsIgnorePattern': '^_' }]
}
};

Step 7: Docker Compose for Development

What this step does: Creates a Docker Compose file that makes it easy to run your application and any supporting services with a single command.

Create docker-compose.yml:

version: '3.8'

services:
app:
build: .
ports:
- "3000:3000"
environment:
- NODE_ENV=development
- PORT=3000
restart: unless-stopped
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
interval: 30s
timeout: 10s
retries: 3
start_period: 10s

Step 8: Test Everything Locally

What this step does: Shows you how to actually run and test your application locally before deploying it.

Install and Test Locally

Install all dependencies from package.json

npm install

Run your test suite to make sure everything works

npm test

What you'll see:

Tests should pass with green checkmarks: ✓ GET / should return welcome page
Server starts and shows: 🚀 Server running at http://localhost:3000/

The test ran was successful.

Start the application server

npm start

The image above shows that the application is running locally.

Test endpoints (in a new terminal window):

curl http://localhost:3000/ # Homepage

curl http://localhost:3000/health #_ Health check JSON_

curl http://localhost:3000/info # _System info JSON _

curl http://localhost:3000/metrics #_ Prometheus metrics_

Docker Commands

Build image

docker build -t my-devops-app:latest .

Run container

docker run -d \
--name my-devops-container \
-p 3000:3000 \
--restart unless-stopped \
my-devops-app:latest

Check container status

docker ps

docker logs my-devops-container

Test health check

curl http://localhost:3000/health

Stop container

docker stop my-devops-container

docker rm my-devops-container

Docker Compose Commands

Start all services defined in docker-compose.yml

docker-compose up -d

View real-time logs from all services

docker-compose logs -f

Stop all services and clean up

docker-compose down

Step 9: Deploy to GitHub

What this step does: Commits your code to Git and pushes it to GitHub so the automated CI/CD pipeline can start working.

Initial commit

Add all files to Git staging area

git add .

Create your first commit with a descriptive message

git commit -m "Initial commit: Complete DevOps setup with working CI/CD"
Connect to GitHub

⚠️ IMPORTANT: Before running these commands:

Go to GitHub.com and create a new repository called my-devops-project
DO NOT initialize it with README, .gitignore, or license (we already have these)
Copy the repository URL from GitHub
Replace YOUR_GITHUB_USERNAME below with your actual GitHub username

Set main as the default branch

git branch -M main

Connect to your GitHub repository (UPDATE THIS URL!)

git remote add origin https://github.com/YOUR_GITHUB_USERNAME/my-devops-project.git

Push your code to GitHub for the first time

git push -u origin main

What you'll see: Your code appears on GitHub, and the CI/CD pipeline starts running automatically.

Step 10: Kubernetes Deployment Configurations

What this step does: Creates Kubernetes configuration files that define how your application should run in staging and production environments.

Create directories

Create directories for Kubernetes configurations

mkdir -p k8s/staging k8s/production

Create Staging Deployment

Create k8s/staging/deployment.yml:

⚠️ IMPORTANT: Update YOUR_GITHUB_USERNAME in the image URL below!

Create Production Deployment

Create k8s/production/deployment.yml:

⚠️ IMPORTANT: Update YOUR_GITHUB_USERNAME in the image URL below

Step 11: Complete Deployment Workflow.

What this step does: Shows you how to use the complete CI/CD pipeline with proper branching strategy for staging and production deployments.

Branch-based Deployment Strategy
develop branch → Automatically deploys to staging environment
main branch → Automatically deploys to production environment
Pull requests → Run tests only (no deployment)
Deploy Changes
Deploy to staging:

Create and switch to develop branch

git checkout -b develop

Make your changes, then commit and push

git add .

git commit -m "Add new feature"

git push origin develop

What happens: GitHub Actions automatically runs tests and deploys to staging.

Deploy to production:

Switch to main branch

git checkout main

Merge changes from develop

git merge develop

Push to trigger production deployment

git push origin main

What happens: GitHub Actions runs full pipeline and deploys to production.

[Boost]

Victoria Oludamilola Oyewole — Sun, 22 Jun 2025 20:33:24 +0000

Victoria Oludamilola Oyewole

Jun 22 '25

CONTAINERIZATION

#beginners #tutorial #devops #opensource

Comments 1

8 min read

CONTAINERIZATION

Victoria Oludamilola Oyewole — Sun, 22 Jun 2025 20:32:02 +0000

WHAT IS CONTAINERIZATION?

Containerization is a method of packaging an application along with its dependencies, libraries, and configuration files into a single unit called a container. This ensures that the application runs consistently across different computing environments.

In software engineering, containerization is operating-system-level virtualization or application-level virtualization over multiple network resources so that software applications can run in isolated user spaces called containers in any cloud or non-cloud environment, regardless of type or vendor.

Containerization is a software deployment process that bundles an application’s code with all the files and libraries it needs to run on any infrastructure. Traditionally, to run any application on your computer, you had to install the version that matched your machine’s operating system. For example, you needed to install the Windows version of a software package on a Windows machine. However, with containerization, you can create a single software package, or container, that runs on all types of devices and operating systems.

Key Principles of Containerization

Isolation: Containers provide a sandboxed environment, isolating the application from the host system and other containers. This isolation is achieved through OS-level virtualization, where containers share the same host kernel but have separate namespaces and resource control mechanisms.

Portability: Containers can run on any system that supports containerization, such as Linux, Windows, and Mac operating systems. This makes it easier to develop, test, and deploy applications across different environments without worrying about compatibility issues.

Efficiency: Containers are lightweight and have minimal overhead compared to traditional virtual machines (VMs). They share the host OS kernel, which reduces the need for duplicating the OS in each container, leading to better resource utilization and faster startup times.

Scalability
Containers are lightweight software components that run efficiently. For example, a virtual machine can launch a containerized application faster because it doesn't need to boot an operating system. Therefore, software developers can easily add multiple containers for different applications on a single machine. The container cluster uses computing resources from the same shared operating system, but one container doesn't interfere with the operation of other containers.

Fault tolerance
Software development teams use containers to build fault-tolerant applications. They use multiple containers to run microservices on the cloud. Because containerized microservices operate in isolated user spaces, a single faulty container doesn't affect the other containers. This increases the resilience and availability of the application.

Agility
Containerized applications run in isolated computing environments. Software developers can troubleshoot and change the application code without interfering with the operating system, hardware, or other application services. They can shorten software release cycles and work on updates quickly with the container model.

What are containerization use cases?

The following are some use cases of containerization.

Cloud migration
Cloud migration, or the lift-and-shift approach, is a software strategy that involves encapsulating legacy applications in containers and deploying them in a cloud computing environment. Organizations can modernize their applications without rewriting the entire software code.

Adoption of microservice architecture
Organizations seeking to build cloud applications with microservices require containerization technology. The microservice architecture is a software development approach that uses multiple, interdependent software components to deliver a functional application. Each microservice has a unique and specific function. A modern cloud application consists of multiple microservices. For example, a video streaming application might have microservices for data processing, user tracking, billing, and personalization. Containerization provides the software tool to pack microservices as deployable programs on different platforms.

IoT devices
Internet of Things (IoT) devices contain limited computing resources, making manual software updating a complex process. Containerization allows developers to deploy and update applications across IoT devices easily.

How does containerization work?
Containerization involves building self-sufficient software packages that perform consistently, regardless of the machines they run on. Software developers create and deploy container images—that is, files that contain the necessary information to run a containerized application. Developers use containerization tools to build container images based on the Open Container Initiative (OCI) image specification. OCI is an open-source group that provides a standardized format for creating container images. Container images are read-only and cannot be altered by the computer system.

Container images are the top layer in a containerized system that consists of the following layers.

Infrastructure
Infrastructure is the hardware layer of the container model. It refers to the physical computer or bare-metal server that runs the containerized application.

Operating system
The second layer of the containerization architecture is the operating system. Linux is a popular operating system for containerization with on-premise computers. In cloud computing, developers use cloud services such as AWS EC2 to run containerized applications.

Container engine
The container engine, or container runtime, is a software program that creates containers based on the container images. It acts as an intermediary agent between the containers and the operating system, providing and managing resources that the application needs. For example, container engines can manage multiple containers on the same operating system by keeping them independent of the underlying infrastructure and each other.

Application and dependencies
The topmost layer of the containerization architecture is the application code and the other files it needs to run, such as library dependencies and related configuration files. This layer might also contain a light guest operating system that gets installed over the host operating system.

STEPS ON HOW TO CONTAINERIZE AN APPLICATION WITH THE USE OF VISUAL CODE

Download the Visual code application, allow it to run then create a new folder for your work.
Make a Directory(mkdir) to the new file.

Type the command cd(Change directory)to get into the folder you're working in.
Copy the repository for the application into the visual code to clone it.

What is a Repository?
A repository (often abbreviated as repo) is a centralized storage location where all the files and resources of a project are kept. It acts as a folder on the cloud, containing a set of programming files that collectively make up an application. Repositories are essential for collaborative software development, allowing multiple developers to work on the same project simultaneously.

What is Cloning a Repository?
Cloning a Git repository involves creating a local copy of a remote repository on your computer. This allows you to work on the project locally, make changes, and then push those changes back to the remote repository.

Before you can run the application, you need to get the application source code onto your machine.

Clone the getting-started-app repository using the following command:

git clone https://github.com/docker/getting-started-app.git

After the repo has been copied on the VS code to run.

All the files needed for the application has been clone after it has been run. That is, view the contents of the cloned repository. You should see the following files and sub-directories. The files are ones which appeared after red thick box.

             ** BUILD THE APPLICATION IMAGE**

To build the image, you'll need to use a Dockerfile. A Dockerfile is simply a text-based file with no file extension that contains a script of instructions. Docker uses this script to build a container image.

In the getting-started-app directory, the same location as the package.json file, create a file named Dockerfile with the following contents:

syntax=docker/dockerfile:1

FROM node:lts-alpine
WORKDIR /app
COPY . .
RUN yarn install --production
CMD ["node", "src/index.js"]
EXPOSE 3000

Build the image using the following commands:

In the terminal, make sure you're in the getting-started-app directory. Replace /path/to/getting-started-app with the path to your getting-started-app directory. That is, right click on the directory "getting-started-app directory" then select the option of Open in integrated terminal, its terminal will be opened.

Build the image. Type the command below to build the image.

docker build -t getting-started .

The file running on the Docker Engine.

               **START AN APP CONTAINER**

Now that you have an image, you can run the application in a container using the docker run command.

Run your container using the docker run command and specify the name of the image you just created:

   docker run -d -p 127.0.0.1:3000:3000 getting-started

If you take a quick look at your containers, you should see at least one container running that's using the getting-started image and on port 3000. The image below shows the visual code CLI

The running Container of the Docker Desktop

              **  PART 2**

         _** UPDATE THE APPLICATION**_

Update the source code In the following steps, you'll change the "empty text" when you don't have any todo list items to "You have no todo items yet! Add one above!"

1.
In the src/static/js/app.js file, update line 56 to use the new empty text.

No items yet! Add one above!
You have no todo items yet! Add one above!

2. Build your updated version of the image, using the docker build command.

docker build -t getting-started .

3. Start a new container using the updated code.

docker run -dp 127.0.0.1:3000:3000 getting-started.

However, you probably saw an error like this:

docker: Error response from daemon: driver failed programming external connectivity on endpoint laughing_burnell

(bb242b2ca4d67eba76e79474fb36bb5125708ebdabd7f45c8eaf16caaabde9dd): Bind for 127.0.0.1:3000 failed: port is already allocated.

The error occurred because you aren't able to start the new container while your old container is still running. The reason is that the old container is already using the host's port 3000 and only one process on the machine (containers included) can listen to a specific port. To fix this, you need to remove the old container.

** Remove the old container**

To remove a container, you first need to stop it. Once it has stopped, you can remove it. You can remove the old container using the CLI or Docker Desktop's graphical interface. Choose the option that you're most comfortable with.

Remove a container using the CLI Get the ID of the container by using the docker ps command.

*docker ps

Use the docker stop command to stop the container. Replace with the ID from docker ps.

*docker stop

Once the container has stopped, you can remove it by using the docker rm command.
```
       ** Start the updated app container**
```

1.
Now, start your updated app using the docker run command.

docker run -dp 127.0.0.1:3000:3000 getting-started

2.Refresh your browser on http://localhost:3000 and you should see your updated help text.

AZURE COMPUTE GALLERY AND VIRUAL MACHINE SCALE SET

Victoria Oludamilola Oyewole — Tue, 24 Dec 2024 02:53:35 +0000

What is Compute Gallery?

Azure Compute Gallery (formerly known as Shared Image Gallery) is a feature in Microsoft Azure that helps you manage and distribute custom virtual machine (VM) images efficiently across your organization. It allows you to create, share, and maintain versions of images, making it easier to scale deployments and ensure consistency across your VMs.It is also an infrastructure as a service.

Key Features of Azure Compute Gallery:

Custom Image Management:
- You can create and store custom VM images for reuse across multiple deployments.
- Supports creating multiple versions of an image to manage updates and rollbacks.
Image Sharing:
- Images can be shared across subscriptions, regions, or with other Azure tenants.
- Facilitates collaboration and standardization across teams.
Scaling Deployments:
- Distributes images to multiple Azure regions, enabling quicker VM deployments globally.
- Replicates images across regions, ensuring high availability.
Consistency:
- Ensures uniform configurations by using the same image across different environments (e.g., development, testing, production).
Efficiency with Image Replication:
- Optimized for faster image replication, improving the performance of large-scale deployments.
- Reduces storage costs by eliminating the need to maintain separate copies for each region.
Support for Multiple Resource Types:
- You can store and distribute virtual hard disks (VHDs), managed images, and custom VM configurations.
RBAC Integration:
- Integrates with Azure Role-Based Access Control (RBAC) for secure sharing and management of images.

Typical Use Cases:

Standardized VM Deployments: Ensure all VMs in your environment are built from consistent base images.
Global Applications: Distribute custom VM images across regions for global applications to minimize latency.
Multi-Subscription Management: Share custom VM images across multiple subscriptions within an organization.
DevOps Pipelines: Automate VM image creation and sharing as part of CI/CD pipelines.

By using Azure Compute Gallery, organizations can simplify image lifecycle management, improve deployment times, and maintain operational consistency.

What is Virtual Machine Scale Sets?
Azure Virtual Machine Scale Sets (VMSS) is a service in Microsoft Azure that allows you to deploy and manage a group of identical, load-balanced virtual machines (VMs). It is designed to automatically scale the number of VMs in response to demand or schedule, making it ideal for scenarios requiring high availability and scalability.

Key Features of Virtual Machine Scale Sets

Automatic Scaling:
- VMSS can automatically scale the number of instances based on CPU, memory, or custom metrics using Azure Monitor autoscale rules.
- Supports scaling out (adding VMs) and scaling in (removing VMs) based on demand or a predefined schedule.
Load Balancing:
- Integrated with Azure Load Balancer or Azure Application Gateway to distribute traffic evenly across VMs.
- Ensures high availability and fault tolerance.
Uniform or Flexible Orchestration:
- Uniform orchestration mode: All VMs in the scale set are identical, ideal for stateless workloads.
- Flexible orchestration mode: Allows running VMs with varied configurations, suitable for stateful or mixed workloads.
Integrated Updates:
- Facilitates rolling updates to minimize downtime while upgrading or patching VMs.
- Supports versioning when used with Azure Compute Gallery to deploy specific image versions.
High Availability:
- Distributes VMs across Availability Zones or Fault Domains for resilience against hardware or data center failures.
Custom Images and Extensions:
- Use custom VM images from Azure Compute Gallery.
- Configure VMs with extensions for software installations and custom scripts during deployment.
Multi-Region and Cross-Zone Deployment:
- Deploy VMs across regions or zones to meet redundancy and low-latency requirements.
Support for Spot VMs:
- Cost-efficient option for running interruptible workloads by using Azure Spot instances within scale sets.
DevOps and Automation:
- Integrated with Azure DevOps, CI/CD pipelines, and Infrastructure as Code (IaC) tools like ARM templates, Terraform, or Bicep.

Typical Use Cases

Web Applications:
- Host large-scale web apps or APIs with automatic scaling to handle varying traffic loads.
Big Data and Batch Processing:
- Run parallel batch jobs or distributed data-processing workloads with dynamic scaling.
Microservices:
- Deploy containerized applications where each VM can host containers with Kubernetes or other orchestrators.
High-Performance Computing (HPC):
- Scale up/down compute power for intensive workloads like simulations or AI/ML model training.
Cost Optimization with Spot VMs:
- Use Spot VMs for non-critical workloads to save costs.

Advantages of Virtual Machine Scale Sets

Elasticity: Automatically adjusts resources to match demand, optimizing performance and cost.
High Availability: Redundant VMs ensure minimal downtime during failures.
Centralized Management: Simplifies operations by managing identical VMs in a group.
Global Reach: Facilitates seamless deployment across multiple Azure regions and zones.

In summary, VMSS is a powerful tool for building scalable, reliable, and cost-effective applications in Azure. It is particularly suited for workloads requiring dynamic scaling or high fault tolerance.
.

The Steps on Azure compute Gallery and Virtual Machine Scale Set

                     (part 1)

Log into your Azure Account.

-Search at the tool box, Select and Create a Virtual Machine.

-If you have a Virtual Machine been created, you can start it again.

In the search bar, search for Settings and Select Disk. There is OS(Operating Disk) Disk and Data Disk. It is on the Data Disk we want to work to generate space due to the Image wanted to be stored.

Click on the Data Disk section, and generate number of disk wanted ** (LUN), ** Name of Disk (datadisk), Storage type(choose standard SSD) for smooth and faster running of the system and Size GiB (the memory of the disk needed). leave everything as default and then, Apply the rule.

A Disk has been attached.

Go to the Overview page.
Go to the search bar and select Connect

Select the Connect Icon and on the Native RDP button, select the *Select button.
*
The selection of the select button opens the RDP page, where the configured button will clicked and Download RDP will be clicked.

Downloading of the RDP file to connect the Virtual Machine

In the VM environment, search for Disk Management, click on it, it will give you the environment below. Click on OK to initialize what has been created.

Click on the data disk created, right click on it, you will find "New Simple Volume Wizard", click on the next button

Keep on clicking on the next button until you find this area that identifies the partition of the disk. Give it name like data disk. click on the next button to finish the process.

In the interphase below, the partition is done, click on the *Finish button. Then the disk is useable. *

                           Part 2

                 Azure Compute Gallery Creation

Azure Compute Gallery (formerly known as Shared Image Gallery) is a service in Microsoft Azure that simplifies the process of sharing and managing images for virtual machines (VMs) at scale. It enables you to create, manage, and replicate VM images efficiently across multiple regions and subscriptions.

The Procedures;

Log into your Azure account and search for Azure Compute Gallery, it's an application on it's own in Azure.

Select + Create button

Create the Resource Group, Give it the name, Description and select Review + create.

Go back to the VM created and select Capture.

On the Capture button select the Image icon

While creating the Compute Gallery Resource Group, make sure that the Virtual Machine Resource Group are the same with it.

However, while creating the Compute Gallery and and capturing the Image on the virtual Machine, for the Operating System State there is an option of Generalized and Specialized. Choosing the option of Generalized will make people attached to it's usage will be asking of the username and password consistently. But a Specialized will automatically log into site.

The next step is, click on Target the VM Image Definition, it will pop up the box beside it with the title Create a VM Image Definition, write the VM image definition name and click on OK

While an image is being created, the Image creation will stop the Virtual Machine that is running before the its creates the image.

Moreso, in Virtual Machine Scale Set process, there is what is called Horizontal Scaling. That is, when the traffic is too much, such that, when the number of people wanting to log into an app is to much, the scaling out occur(scaling out number of VMs) so that, there will many instances of VMs. When the number reduced, it scales in and shut down the number of VMs that have been created.

USING THE IMAGE CREATED TO CREATE A VIRTUAL MACHINE

Go to resource after the deployment of the the Capture Image.

Click on + Create VM button
Creation of Instances Details

The Image created is part of the image instances.

                          PART 3
            HOW TO CREATE VIRTUAL MACHINE SCALE SET

Go to the Resource of the Azure Gallery created, select + create VMSS icon

Create the VMSS name.

Choosing of Orchestration Mode

Orchestration Mode is the kind of mode a virtual machine scale sets want to operate on. Choose how virtual machines are managed by the scale set. In flexible orchestration mode, you manually create and add a virtual machine of any configuration to the scale set. In uniform orchestration mode, you define a virtual machine model and Azure will generate identical instances based on that model.

It is in two part;
Flexible: achieve high availability at scale with identical or multiple virtual machine types.
Uniform: optimized for large scale stateless workloads. Being stateless means, when something doesn't store information about what it did.

Scaling: choosing manual scaling up of VM when the users number grown.

Click on** Review + create button*, then **create*

Go to Resource

GO to Scaling Icon to scale up the VM manually to many instances in need. And save.

Go back to the Virtual Machine icon to see the numbers of instances selected to be created and it has been created.

[Boost]

Victoria Oludamilola Oyewole — Thu, 12 Dec 2024 10:42:06 +0000

AN S3 BUCKET CREATION ON AWS AND HOW TO PRESIGNED URL TO IT

Victoria Oludamilola Oyewole ・ Dec 11 '24

#webdev #beginners #programming #aws

AN S3 BUCKET CREATION ON AWS AND HOW TO PRESIGNED URL TO IT

Victoria Oludamilola Oyewole — Wed, 11 Dec 2024 02:46:37 +0000

What is an S3 Bucket?

An S3 bucket in AWS (Amazon Web Services) is a cloud-based storage container within the Amazon Simple Storage Service (S3). S3 buckets are used to store, organize, and manage data as objects. Objects in an S3 bucket include the data itself, along with metadata and a unique identifier.

Key Features of S3 Buckets:

Storage of Any Data Type: You can store files such as images, videos, documents, backups, and application data.
Global Namespace: Each bucket name must be globally unique across all AWS regions.
Scalable and Durable: AWS S3 is designed for 99.999999999% (11 nines) of durability.
Secure: Supports features like encryption, access control lists (ACLs), and bucket policies to control who can access your data.
Versioning: You can enable versioning to maintain multiple versions of an object.
Lifecycle Management: Rules can be set to transition data to cheaper storage classes or delete them after a specified period.
Storage Classes: Various storage classes like S3 Standard, S3 Glacier, and others optimize cost and performance based on access frequency.
Integration with Other AWS Services: S3 integrates seamlessly with services like AWS Lambda, EC2, and CloudFront.

How It Works:

Buckets: These are the containers where objects (files) are stored.
Objects: Each object consists of data and metadata.
Keys: Unique identifiers for each object in a bucket.
Regions: Buckets are created in specific AWS regions to optimize performance and comply with data residency requirements.

For example:

You could create a bucket called my-photos-bucket and store images in it.
Access control can be set to allow only authorized users or systems to retrieve the data.

AWS S3 is widely used for web applications, content delivery, backups, and data lakes due to its simplicity, reliability, and scalability.

The Steps of Creation:

Log into the AWS account and search for S3 Bucket at the search bar icon, click on Bucket.

-** Add a name** that is globally unique in lower case format and then click on *create Bucket *

On the page of Bucket Creation, add Bucket name.

Still on the page, on the Object Ownership section, Block Public Access settings for this bucket leave as default the area which says Block all public access

Disable the Bucket Versioning

Leave other annotated area as default then Create.

The environment of the S3 Bucket after creation.

How to Upload an Image in it?

Click on the Bucket created to upload an image in it. After the inserting the object, upload.

The object insertion to be uploaded.

How to share with Presigned URL for any image uploaded? This explains how to view any image uploaded for some minutes by copying the URL into a browser to view.

Copy the Presigned URL to browser to view for 2 minutes, and it can also be downloaded or be opened.

HOW TO CREATE EC2 INSTANCE ON AMAZON WEB SERVICES AND INTALLATION OF IIS WEB-SERVER

Victoria Oludamilola Oyewole — Mon, 09 Dec 2024 13:12:30 +0000

What is EC2?
EC2, or Amazon Elastic Compute Cloud, is a service provided by Amazon Web Services (AWS) that allows users to rent virtual servers (instances) on the cloud to run applications. It offers scalable computing capacity, making it easier for developers to build and deploy applications without needing to invest in physical hardware.

Key Features of EC2:

Elasticity: You can quickly scale up or down the number of instances based on your workload.
Instance Types: EC2 provides a variety of instance types optimized for different use cases, such as compute-intensive tasks, memory-intensive applications, or general-purpose needs.
Flexible Pricing:
- On-Demand Instances: Pay for compute capacity by the hour or second with no upfront costs.
- Reserved Instances: Commit to using an instance for a specific period (e.g., 1 or 3 years) for a discounted rate.
- Spot Instances: Use unused EC2 capacity at a lower price, suitable for flexible or interruptible workloads.
Storage Options:
- Elastic Block Store (EBS): Persistent block storage for data that persists independently of the instance lifecycle.
- Instance Store: Temporary storage tied to the lifecycle of the instance.
Security: Provides features like Virtual Private Cloud (VPC), security groups, and IAM roles to secure access to resources.
Global Availability: Instances can be deployed in multiple geographic regions and availability zones for redundancy and low-latency access.
Integration with Other AWS Services: Seamlessly integrates with AWS services like S3, RDS, and Lambda for a complete cloud ecosystem.

Common Use Cases:

Web hosting
Application development and testing
Big data processing
High-performance computing
Running containerized applications using services like Docker or Kubernetes

EC2 is a foundational component of AWS's Infrastructure as a Service (IaaS) offerings, providing the flexibility and control needed to customize the computing environment to specific requirements.

The Steps

Log into the Browser and search for AWS.
Create your account.
Log into the account after the creation. Below is the environment of the AWS after the account creation.

In the search box, search for EC2, after poping up, click the box. In the box, click on Instances

Click on** Launch Instances**

Click the box and give the Instance you wanted to create a name of your choice.e.g 'ambassador'.

Click on the 'Add additional tags' icon to add more tags to the instance. Tags are for identification.

Clicking on the additional tags will bring this below;

Click on Stockholm icon to select the** Region**.

Scroll to the Application or OS image region to select the type of Image suitable for your operation.

Select the kind Instance that won't cost so much.
Create a Key Pair name.

On the Network Security, Select Allow Http from the internet

On the Configure Storage, you can increase the memory.

Click the Launch icon.
It has successfully launched.

Click on Connect to Instance.

Click on RDP Client Icon

Click on Download Remote Desktop file

Go to the Desktop file to open it up

Click on the Get password

Click on upload private key file and then click Decrypt Password

Click on the Key Pair Downloaded and Open.

After the Download of the Key Pair, Decrypt Password

The Password after been Decrypt. Copy it, and Go to RDP File been downloaded to connect the EC2 Instance.

The environment of the Instance

Opening of PowerShell in the EC2 instance environment, run it as an Administrator, to Install the Web-Server Management Tool in it.

The environment of the Web-server after the installation in the EC2 Instance.

Return to the AWS account to copy the Public IP address to indicate that something has been install on the EC2 Instance and is on the Browser.

The environment of the Browser.

WEB APPLICATION CREATION IN AZURE

Victoria Oludamilola Oyewole — Wed, 20 Nov 2024 13:09:19 +0000

Web application creation in Azure refers to building, deploying, and managing web applications using Azure's cloud infrastructure and services. Azure provides a variety of tools and platforms to help create and host web applications, both simple and complex, while managing scalability, security, and availability. Here's a breakdown of key concepts and steps involved:

1. Azure App Service

Azure App Service is the primary platform for creating and hosting web applications, RESTful APIs, and mobile backends. It supports multiple programming languages and frameworks, including .NET, Node.js, PHP, Python, and Java.
App Service provides built-in infrastructure management, so developers don't need to worry about the underlying hardware or operating system.

2. Setting Up a Web App

You can create a web app in the Azure portal, using Azure CLI, or through tools like Visual Studio.
You specify configurations, such as runtime stack (e.g., Node.js, .NET), region, and scaling requirements.
Azure App Service allows you to configure deployment options, such as deploying directly from code repositories like GitHub, Azure Repos, or local files.

3. Customizing Resources and Scaling

App Service Plans let you control the resources (CPU, memory, etc.) allocated to your app, based on the pricing tier. You can scale up (higher resources) or scale out (more instances) as needed.
Autoscaling can be set up to automatically adjust the app's resources based on demand.

4. Deployment and CI/CD

Azure supports continuous integration and continuous deployment (CI/CD) using GitHub Actions, Azure DevOps, or other CI/CD tools.
This means you can automate deployments, enabling changes to your web app to go live immediately after code updates.

5. Additional Features

Authentication and Authorization: Azure App Service allows for setting up user authentication with providers like Azure AD, Facebook, Google, and more.
Monitoring and Diagnostics: Azure provides tools like Application Insights and Log Analytics for monitoring performance and diagnosing issues.
Domain and SSL: You can configure custom domains and SSL/TLS certificates for secure connections.

6. Using Additional Azure Services

You can connect your web app to other Azure services, like Azure SQL Database, Cosmos DB, or Azure Blob Storage, for databases and storage.
Use Azure Functions for serverless operations if you need to perform event-driven tasks alongside your web application.

Azure's tools make it straightforward to build, deploy, and manage web applications with a focus on scalability, security, and performance.

3 Core Components to Host Web Application

A Resource Group.
An Empty Web Application.
An Plan- App plan is where an App Service is hosted, more like a computer resource. It is also defines as a set of computer resource for a web app to run.

Getting Started with Azure Web Apps

To start creating a web app on Azure:

Go to the Azure Portal

2.Select + Create Web App

Choose Create a resource > Web App.
Fill in details (app name, runtime stack, and region), and create a new or select an existing App Service Plan.
Deploy your code and configure any additional features as needed.

Select Review + Create

2. Creation of a web code through Chatgpt
A code is needed concerning the kind of web to be created. That is, in a organisation, the programmers are eligible to create a code for any any application to run. But in this regard, web creation through the use of Azure service without the use of a programmer, ChatGPT is use for the code creation.

Log on to ChatGPT and type the code on any application wished to generate. For instance,
*sample HTML javascript application for women and girls fashion all in one file.
*

3. Go back to Azure portal to replicate the code.

In the portal, in the search bar, search for advance tool. Click on it, and click the Go button.

The Go button clicked on will bring you to the new environment below.
Click on the Debug Console and select CMD Icon

Coming into the new environment, click on the button *Site *

Click on the the wwwroot button to copy into the code generated from ChatGPT.

Copy and Save the code.

Go back to the Azure portal to your resource, then click on the Default Domain to check the code copied.

DEPLOYMENT SLOTS

Deployment Slots in Azure App Service are a powerful feature that allows you to manage and deploy multiple versions of your application within the same App Service. These slots enable testing, staging, and smooth rollouts of updates without downtime, providing a streamlined way to handle production deployments.

Key Features of Deployment Slots:

Multiple Slots:
- Each App Service Plan can support multiple deployment slots (e.g., staging, testing, production).
- The primary slot is typically production, while others can be used for testing and staging.
Slot Swapping:
- You can swap the content and configuration of one slot with another.
- This feature is commonly used to move a tested version of the app from staging to production seamlessly.
Configuration Management:
- Each slot has its own independent configuration settings (e.g., connection strings, environment variables).
- You can configure some settings to "stick to a slot" so they don't change during swaps (e.g., production-specific database credentials).
Traffic Control:
- It’s possible to direct a percentage of live traffic to non-production slots to test new features under real user conditions.
Zero Downtime Deployment:
- Deployment to a non-production slot ensures the primary (production) slot remains unaffected during updates.
Rollback Capability:
- If an issue is detected after swapping slots, you can quickly swap them back to roll back to the previous version.

Typical Workflow:

Deploy the new version of your app to a staging slot.
Test the new version in the staging environment.
Swap the staging slot with the production slot for seamless deployment.
Monitor the app and roll back if needed by swapping the slots again.

Benefits:

Testing in a Production-Like Environment: Deployment slots allow you to validate changes in an isolated environment that mirrors production.
Improved Reliability: Changes can be reverted quickly, minimizing downtime or impact on users.
Flexibility: Teams can deploy and test multiple versions of the app simultaneously.

Limitations:

The number of slots available depends on the App Service Plan tier (e.g., Basic has no slots, Standard supports up to 5, and Premium supports more).
Slots share the same resources (CPU, memory) as the production slot, so performance impacts may occur if resource-intensive activities are running in multiple slots.

Getting Started with Deployment Slots in Azure Web Service.

Log into the the Azure portal, search for Deployment Slot

Click on add slot

Click on the name, app to use and Add

Removal of 10% out the 100% of traffic to test the new App developed. That is, a certain % is needed to test any new app developed before it's finally launched

Swap: after the new app has been tested by certain percentage of the audience, the reactions given to it will enable adjustment or launching out of the app. If these certain people used, applauded this new app, their percentage will be added back to the production.

The 10% taken out to test the new feature App has been added back to the production.

MONITORING

Monitoring in Azure Web Apps involves tracking the performance, health, and availability of your web applications hosted on the Azure platform. It provides insights into how your application is functioning and helps detect and diagnose issues to ensure smooth operation. Azure offers several tools and features for monitoring web apps:

1. Azure Monitor

Overview: Azure Monitor is the primary monitoring solution in Azure. It collects, analyzes, and visualizes telemetry data.
Capabilities:
- Performance monitoring
- Log analysis
- Alerts and notifications
Data Sources:
- Metrics: Real-time data such as CPU usage, memory consumption, and response times.
- Logs: Historical data including application events and diagnostic logs.

2. Application Insights

Purpose: A part of Azure Monitor, designed specifically for application performance monitoring (APM).
Key Features:
- Tracks requests, dependencies, exceptions, and custom events.
- Provides detailed performance metrics like response time and failure rates.
- Offers live metrics stream to monitor real-time performance.
- Supports distributed tracing for microservices.
Integration:
- Can be integrated with various frameworks (e.g., .NET, Java, Node.js, Python).
- Provides an SDK for custom telemetry.

3. Diagnostics and Logs

Application Logs: Capture application-level logs for debugging issues.
Diagnostic Logs: Include detailed system and network-related information.
Streaming Logs: View logs in real time using Azure CLI or Azure portal.
Log Analytics: Query logs for insights using KQL (Kusto Query Language).

4. Health Checks

Azure App Services support health probes to monitor the application's readiness and availability.
You can configure custom endpoints that Azure pings periodically to check application health.

5. Alerts

Configure alerts for specific metrics or log conditions.
Supports notifications via email, SMS, or integration with services like PagerDuty and Slack.
Example: Set up an alert for high CPU usage or HTTP 5xx error rates.

6. Performance and Availability Monitoring

Availability Tests: Simulates user interactions from different geographic regions to test application responsiveness.
Metrics Dashboard: Visualize key performance metrics and trends in the Azure portal.

7. Integration with Third-party Tools

Azure supports integration with tools like Grafana, Splunk, and Elastic for advanced monitoring and visualization.

Why Monitoring Matters:

Proactive Issue Detection: Identify problems before users report them.
Performance Optimization: Understand bottlenecks and optimize resource usage.
Business Insights: Monitor user behavior and track key metrics that affect your application’s success.
Compliance and Auditing: Ensure your application meets performance and uptime SLAs.

By leveraging these monitoring capabilities, you can ensure your Azure Web App is reliable, performant, and user-friendly.

The process

In the Azure portal, search and click on Monitoring

Click on the kind of alert the app should give. For instance, Http Server error
After the creation of the kind of rule to give which will be found on the Details bar, click on Review + Create.

APPLICATION INSIGHTS

In the same Azure portal, search for Application Insight, it is automatically Enable and Apply.

Click Yes to Apply the Monitoring Settings.

LINUX: AN OPERATING SYSTEM AND THE USE OF ITS COMMANDS

Victoria Oludamilola Oyewole — Wed, 13 Nov 2024 03:32:58 +0000

WHAT IS LINUX?
Linux is a free, open-source operating system (OS) that acts as an intermediary between computer hardware and software applications, managing resources and executing instructions. Created by Linus Torvalds in 1991, it is modeled on UNIX but has since evolved independently. Linux is known for its stability, flexibility, and security, making it popular for servers, desktops, and embedded systems.

Moreso, Linux is a versatile and powerful operating system that has found a broad range of applications, from personal computing to powering the world’s most complex supercomputers. Its design follows a Unix-like architecture, focusing on stability, performance, security, and flexibility. Here’s a deeper dive into what makes Linux unique and why it’s so widely used.

The key features of Linux as an OS include:

1. Open-Source Nature and Community Collaboration

Freedom and Flexibility: Linux is open-source software, meaning anyone can view, modify, and distribute its code. This openness has led to widespread collaboration, with thousands of developers worldwide contributing to its evolution.
Community Support: The open-source community is a massive asset, providing support, resources, and continuous improvements. This collaborative model encourages rapid innovation and quick identification and patching of security issues.
Forking and Variants: Because of its open nature, developers can create customized versions or "forks" of Linux, resulting in a variety of distributions. Each distribution (e.g., Ubuntu, CentOS, Arch Linux) serves different needs, whether for servers, desktops, or lightweight embedded systems.

2. Security and Reliability

Permissions and User Management: Linux’s design inherently prioritizes security. Permissions and user roles are strictly managed, limiting what users (and software) can do, which reduces the risk of malware and security breaches.
Regular Security Updates: The collaborative model of Linux means that security vulnerabilities are often identified and patched quickly, helping it maintain a reputation for reliability.
Strong Community Auditing: Linux is widely audited by security experts and developers worldwide, enhancing its robustness against threats.

3. Efficient Resource Management

Lightweight and Scalable: Linux can run efficiently on hardware ranging from low-power microcontrollers to high-performance mainframes and supercomputers. This scalability makes it a go-to choice for diverse environments.
Customizable Kernel: Users and developers can customize the Linux kernel to fit the exact hardware specifications and performance needs of the machine it’s running on, optimizing resource use.
Ideal for Servers: Linux’s efficient resource management and stability make it a top choice for web servers, with over 90% of all servers on the internet running on a Linux-based OS.

4. Command Line Interface (CLI) and Scripting

Powerful CLI: Linux’s command-line interface provides power users and system administrators fine-grained control over the system. From managing processes to editing configuration files, the CLI is a powerful tool for experienced users.
Scripting and Automation: Linux has excellent support for scripting languages (such as Bash, Python, and Perl) that allow users to automate repetitive tasks, perform batch processing, and streamline system management.

5. Distributions (Distros) and Use Cases

General-Purpose Distros: Distributions like Ubuntu, Fedora, and Debian offer user-friendly environments for everyday desktop users, developers, and business applications.
Server-Specific Distros: Distributions like CentOS, Red Hat Enterprise Linux (RHEL), and SUSE are tailored for enterprise-level servers and critical applications, with a focus on reliability, support, and security.
Minimalist and Embedded Systems: Lightweight distributions like Alpine Linux and Tiny Core Linux are ideal for devices with limited resources, such as embedded systems or IoT devices.
Customizable Distros: Arch Linux and Gentoo provide a highly customizable experience, allowing advanced users to build their Linux system from the ground up.

6. Linux in Cloud Computing and Virtualization

Cloud Dominance: Linux is widely used in cloud environments due to its scalability, security, and lightweight nature. Cloud providers like AWS, Google Cloud, and Microsoft Azure offer various Linux distributions as default images for cloud instances.
Containerization with Docker: Linux's modular nature has made it the preferred OS for containerization platforms like Docker and Kubernetes. Linux Containers (LXC) and namespaces allow isolated environments within a single OS instance, driving efficiency in cloud-native applications.
Virtualization Support: Linux provides robust support for virtualization with tools like KVM (Kernel-based Virtual Machine) and Xen, enabling multiple virtual machines to run on a single physical machine.

7. Educational and Development-Friendly Environment

Tool Richness: Linux is favored by developers for its compatibility with programming languages, development tools, and version control systems like Git.
Learning Platform: Many people start with Linux when learning programming, networking, or cybersecurity because it provides hands-on experience with these fields. Linux-based systems are also commonly used for running simulation and penetration testing labs, making them ideal for educational purposes.

8. Popularity and Adoption in Industry

Web Hosting and Data Centers: Linux is the dominant OS in the world of web hosting, powering websites, APIs, and other internet services. The Apache and Nginx web servers, which are typically run on Linux, are among the most popular web server software.
Supercomputing and Research: Over 90% of the world’s supercomputers run on Linux because it can handle massive workloads and be customized for high-performance computing (HPC) requirements.
Mobile and Embedded Devices: Android, which is based on the Linux kernel, is the world’s most popular mobile OS. Additionally, many embedded systems like routers, smart TVs, and IoT devices run on customized Linux versions.

Downloading process and Navigating through Linux Commands

Search the Web for Ubuntu Multipass Download

Select the OS for the PC in use.

Select and run any of the virtual Box given.

The environment after the download and installation.

Navigating through the Commands

The first command in the Linux environment is 'Sudo su'

Sudo su: (Super User) puts you into the root environment. The SU command is used to run a function as a different user. It is the easiest way to switch or change to the administrative account in the current logged in session.

Navigating through File System

pwd: means the current working directory. That is, it shows the current directory you are in.

ls: means List. It helps to know the list of things or items in the directory. For instance, in the below annotation, vicky and vicky 2 are the items already in the directory.

mkdir: mean Make Directory. A Directory is like a cupboard to make a new directory file.

ls-l: it shows all the permission been given so far in the machine.

cd: mean Change Directory

Exist- mean moving out from the environment.
Clear- mean clearing up of the the page.

File and Directory Operations

touch: to create a new empty file e.g touch(name prefer to be given to the file)

cp: mean copy a file from the source to a destination. e.g cp vickyresume (source file) ambassadorfile1(destination file)

mv: move a file to a destination i.e from a source to a destination
cat: mean display the contents of a file.
rm: mean remove file or delete a file

In the image 1 above, the file named_ "dammie1.txt"_ was included but in image 2, the file name_ "dammie1.txt"_ has been removed.

Commnand Mode: mean the environment a text file will be work upon. i.e it is an environment to type into before it is being edit, copy and the likes. For typing to be made in this environment, you type "I" which means "Insert"

Viewing and Editing a File

cat: mean view the content of a file.

less: (typing file name with "less"). This will enable the viewing of the contents of a file at one screen at a time.

vim:(vim with filename) to edit a file, vim is use.It will also open a file and edit it.

More to the use of Vim.

In this write, we will dive deep into the world of Vim, a powerful text editor that is widely used in the Linux environment for creating and editing text files. Vim, short for Vi Improved, is a highly customizable and efficient text editor that offers a wide range of features to enhance your text editing experience. Let's explore how you can work with Vim to create and edit text files in Linux.

1. Opening Vim:
To open Vim, simply type 'vim' followed by the name of the file you want to edit. For example, to edit a file named 'example.txt', you would type 'vim example.txt' in the terminal.

2. Navigating in Vim:
Once you have opened a file in Vim, you can navigate through the text using the arrow keys or the 'h', 'j', 'k', and 'l' keys for left, down, up, and right movements respectively.

3. Editing Text:
To start editing text in Vim, press the 'i' key to enter insert mode. You can now type or paste text into the file. To exit insert mode and return to normal mode, press the 'Esc' key.

4. Saving and Exiting Vim:
To save changes to the file and exit Vim, you can use the following commands:

Press ':w' and then 'Enter' to save the changes without exiting Vim.
Press ':wq' and then 'Enter' to save the changes and exit Vim.
Press ':q!' and then 'Enter' to exit Vim without saving changes.

5.Advanced Editing Techniques:
Vim offers a wide range of advanced editing techniques such as search and replace, copying and pasting, and navigating multiple files. By mastering these techniques, you can significantly improve your productivity when working with text files in Linux.

** How to Delete Directories and Files in Linux.**

In the world of Linux, knowing how to efficiently delete directories and files is a crucial skill for any Cloud DevOps professional. 🌟

Step 1: Deleting Files
Deleting files in Linux is a straightforward process. You can use the 'rm' command followed by the file name to remove a specific file. For example, to delete a file named 'example.txt', you would use the command 'rm example.txt'. Remember, this action is irreversible, so use it with caution. 💥

Step 2: Deleting Empty Directories
To delete an empty directory, you can use the 'rmdir' command followed by the directory name. For instance, if you want to remove a directory named 'docs', you would type 'rmdir docs'. Keep in mind that 'rmdir' can only delete empty directories. 📁

Step 3: Deleting Non-Empty Directories
Deleting directories with content requires a different approach. You can use the 'rm' command with the '-r' flag to recursively remove all files and subdirectories within the target directory. For example, to delete a directory named 'project' and all its contents, you would use 'rm -r project'. Exercise caution when using this command, as it will delete everything within the specified directory. 🚨

By mastering the art of deleting directories and files in Linux, you can effectively manage your system and free up valuable storage space. Practice these commands in a safe environment to become proficient in handling file deletion tasks.

System Information and Management

uname-a : this command will display detailed information about the system in use.

df-h:(human-readable format) this command will display disk space usage.

free-h: (human-readable format) this command will display the memory usage.

top: this command will display the processes and system resource usage. That is, it will show that the system is running or in usage.

Searching and Finding

grep: (pattern or search item). Grep with the name of the file being searched for_(grep information newfile.txt_).This command is used to search for a file in the situation where there are numerous files.

How to Quit vim/vi Editor

Press _Escape _key on your keyboard.
Press Shift and :
Type :wq

In Summary

Linux’s power, flexibility, and open-source nature have allowed it to permeate nearly every sector, from everyday devices like smartphones to specialized systems like research supercomputers. Its community-driven development and emphasis on security, efficiency, and customizability make Linux an enduring and evolving choice in modern computing.

STORAGE ACCOUNT: HOW TO ASSIGN AND MANAGE KEY

Victoria Oludamilola Oyewole — Wed, 30 Oct 2024 13:23:55 +0000

Skilling tasks

Create the storage account and managed identity.
Secure access to the storage account with a key vault and key.
Configure the storage account to use the customer managed key in the key vault.
Configure an time-based retention policy and an encryption scope.

Create the storage account and managed identity.

Provide a storage account for the web app.
In the portal, search for and select Storage accounts.
Select + Create.

For Resource group select Create new. Give your resource group a name and select OK to save your change

Provide a Storage account name. Ensure the name is unique and meets the naming requirements.
Move to the Encryption tab.
Check the box for Enable infrastructure encryption.
Notice the warning, This option cannot be changed after this storage account is created.
Select Review + Create.
Wait for the resource to deploy.

2.Provide a managed identity for the web app to use.

Search for and select Managed identities.

Select Create.
Select your resource group.
Give your managed identity a name
Select Review and create, and then Create.

3.Assign the correct permissions to the managed identity. The identity only needs to read and list containers and blobs.

Search for and select your storage account.
Select the Access Control(IAM)blade

Select Add role assignment (center of the page).

On the Job functions roles page, search for and select the Storage Blob Data Reader role.

On the Members page, select Managed identity.

Select members, in the Managed identity drop-down select User-assigned managed identity.

Select the managed identity you created in the previous step.
Click Select and then Review + assign the role

Select Review + assign a second time to add the role assignment.

Your storage account can now be accessed by a managed identity with the Storage Data Blob Reader permissions.

Secure access to the storage account with a key vault and key

To create the key vault and key needed for this part of the lab, your user account must have Key Vault Administrator permissions.

In the portal, search for and select Resource groups.
Select your resource group, and then the** _Access Control(IAM)blade.**

Select Add role assignment (center of the page).

On the Job functions roles page, search for and select the Key Vault Administrator role.

On the** Members** page , select *User, group, or service principal.
*
Select Select members.
Search for and select your user account. Your user account is shown in the top right of the portal.
Click Select and then Review + assign.

Select **Review + assign **a second time to add the role assignment.
You are now ready to continue with the lab.

2.Create a key vault to store the access keys.

In the portal, search for and select Key vaults.

Select Create.
Select your resource group.
Provide the name for the key vault. The name must be unique.

Ensure on the Access configuration tab that Azure role-based access control (recommended) is selected.
Select Review + create
Wait for the validation checks to complete and then select Create.

After the deployment, select Go to resource.
On the Overview blade ensure both Soft-delete and Purge protection are enabled.

3.Create a customer-managed key in the key vault.

In your key vault, in the Objects section, select the Keys blade.

Select Generate/Import and Name the key.
Take the defaults for the rest of the parameters, and Create the key.

Configure the storage account to use the customer managed key in the key vault.

Before you can complete the next steps, you must assign the Key Vault Crypto Service Encryption User role to the managed identity.

In the portal, search for and select Resource groups.
Select your resource group, and then the Access Control(IAM)blade.

Select Add role assignment (center of the page).

On the Job functions roles page, search for and select the Key Vault Crypto Service Encryption User role.

On the Members page, select Managed identity.
Select Select members, in the Managed identity drop-down select User-assigned managed identity.
Select your managed identity.

Click Select and then** Review + assign**.
Select Review + assign a second time to add the role assignment.

2.Configure the storage account to use the customer managed key in your key vault.

Return to your the storage account.
In the Security + networking section, select the Encryption blade.

Select Customer-managed keys.

Select a key vault and key. Select your key vault and key.
Select to confirm your choices.

Ensure the Identity type is User-assigned.

Select an identity.
Select your managed identity then select Add.
Save your changes

If you receive an error that your identity does not have the correct permissions, wait a minute and try again.

Configure an time-based retention policy and an encryption scope.

The developers require a storage container where files can’t be modified, even by the administrator.

Navigate to your storage account.
In the Data storage section, select the Containers blade.

Create a container called hold. Take the defaults. Be sure to Create the container.

Upload a file to the container.

In the Settings section, select the** Access policy** blade.

In the Immutable blob storage section, select + *Add policy. *

For the Policy type, select time-based retention.
Set the Retention period to 5 days.
Be sure to Save your changes.

Try to delete the file in the container.
Verify you are notified failed to delete blobs due to policy.

2.The developers require an encryption scope that enables infrastructure encryption.

Navigate back to your storage account.
In the** Security + networking** blade, select** Encryption.
**

In the Encryption scopes tab, select Add.

Give your encryption scope a name.
The Encryption type is Microsoft-managed key.
Set Infrastructure encryption to Enable.
Create the encryption scope.

Return to your storage account and create a new container.

Notice on the New container page, there is the Name and Public **access level.**
Notice in the Advanced section you can select the Encryption scope you created and apply it to all blobs in the container.

DEV Community: Victoria Oludamilola Oyewole

WRITING A CONFIGURATION FILE FOR AWS(EC2 CONSOLE) USING TERRAFORM

This command downloads the AWS provider plugin into your project folder. Note the new terraform directory.

This shows you exactly what Terraform is about to create before it actually does it.

Type 'yes' when prompted to confirm the deployment.

[Boost]

A Guide on how to run a Complete CI/CD Pipeline with Node.js, Docker, and Kubernetes.

Victoria Oludamilola Oyewole ・ Oct 3

A Guide on how to run a Complete CI/CD Pipeline with Node.js, Docker, and Kubernetes.

Create package.json with default settings

Install testing and development tools

Install all dependencies (creates node_modules folder)

Create a folder for your tests

Create the main test file

Create the GitHub Actions directory structure

Dependencies node_modules/ npm-debug.log* # Runtime data pids .pid *.seed *.pid.lock # Coverage coverage/ .nyc_output # Environment variables .env .env.local .env..local # Logs logs *.log # IDE .vscode/ .idea/ *.swp *.swo # OS .DS_Store Thumbs.db

Server Configuration PORT=3000 NODE_ENV=production # Logging LOG_LEVEL=info

Install all dependencies from package.json

Run your test suite to make sure everything works

Start the application server

Build image

Run container

Check container status

Test health check

Stop container

Start all services defined in docker-compose.yml

View real-time logs from all services

Stop all services and clean up

Add all files to Git staging area

Create your first commit with a descriptive message

Set main as the default branch

Connect to your GitHub repository (UPDATE THIS URL!)

Push your code to GitHub for the first time

Create directories for Kubernetes configurations

Create and switch to develop branch

Make your changes, then commit and push

Switch to main branch

Merge changes from develop

Push to trigger production deployment

[Boost]

CONTAINERIZATION

CONTAINERIZATION

syntax=docker/dockerfile:1

AZURE COMPUTE GALLERY AND VIRUAL MACHINE SCALE SET

Key Features of Azure Compute Gallery:

Typical Use Cases:

Key Features of Virtual Machine Scale Sets

Typical Use Cases

Advantages of Virtual Machine Scale Sets

[Boost]

AN S3 BUCKET CREATION ON AWS AND HOW TO PRESIGNED URL TO IT

Victoria Oludamilola Oyewole ・ Dec 11 '24

AN S3 BUCKET CREATION ON AWS AND HOW TO PRESIGNED URL TO IT

Key Features of S3 Buckets:

How It Works:

HOW TO CREATE EC2 INSTANCE ON AMAZON WEB SERVICES AND INTALLATION OF IIS WEB-SERVER

Key Features of EC2:

Common Use Cases:

WEB APPLICATION CREATION IN AZURE

1. Azure App Service

2. Setting Up a Web App

3. Customizing Resources and Scaling

4. Deployment and CI/CD

5. Additional Features

6. Using Additional Azure Services

Getting Started with Azure Web Apps

Key Features of Deployment Slots:

Typical Workflow:

Benefits:

Limitations:

1. Azure Monitor

2. Application Insights

3. Diagnostics and Logs

4. Health Checks

5. Alerts

6. Performance and Availability Monitoring

7. Integration with Third-party Tools

Why Monitoring Matters:

LINUX: AN OPERATING SYSTEM AND THE USE OF ITS COMMANDS

1. Open-Source Nature and Community Collaboration

Dependencies node_modules/ npm-debug.log* # Runtime data pids .pid .seed .pid.lock # Coverage coverage/ .nyc_output # Environment variables .env .env.local .env..local # Logs logs .log # IDE .vscode/ .idea/ .swp *.swo # OS .DS_Store Thumbs.db