Prerequisite: Need fundamental scopes in program development and GIT essentials for better read experience for this article.

In the world of DevOps, maintaining a clean and efficient codebase is crucial. One essential tool that helps achieve this is the .gitignore file. But what exactly is a .gitignore file, and why is it so important?

What is a .gitignore File?

A .gitignore file is a simple text file that tells Git which files or directories to ignore in a project. This means that the files listed in a .gitignore will not be tracked by Git and won’t be included in commits.

Why is .gitignore Needed in DevOps?

In DevOps, it’s essential to ensure that your repository remains clean and efficient. The .gitignore file helps in:

• Preventing Clutter: Avoid committing unnecessary files like temporary files, build artifacts, and system-specific files.
• Reducing Repository Size: By ignoring bulky files and directories, the overall repository size is minimized, making it easier to clone and manage.
• Enhancing Security: Sensitive information such as API keys, passwords, and configuration files can be excluded, reducing the risk of accidental exposure.

Use Cases for .gitignore

• Ignoring Build Artifacts: Compiled code, generated files, and build logs that don’t need to be version-controlled.
• Excluding Environment-Specific Files: Configuration files that vary across development, testing, and production environments.
• Omitting System Files: Files generated by the operating system, such as .DS_Store on macOS or Thumbs.db on Windows.
• Avoiding IDE-Specific Files: Project files and settings created by IDEs like Visual Studio, IntelliJ IDEA, or Eclipse.

Notation Examples for .gitignore

Ignoring Specific Files:

secret.txt

This will ignore secret.txt in the repository's root directory.

Ignoring All Files with a Specific Extension:

*.log

This will ignore all files with the .log extension.

Ignoring temporary Files in All Subdirectories:

**/temp/*

This will ignore temp directories and their contents in all subdirectories.

Negating a Pattern:

*.log
!important.log

This will ignore all .log files except important.log.

Ignoring Build Artifacts:

/build
/dist
*.log

This will ignore all changes to build or distributable or any log files.

Avoiding IDE-Specific Files:

.vscode/
.idea/
*.suo

Using the .gitignore file effectively can streamline your DevOps process, making it more efficient and secure. Whether you're a beginner or a seasoned developer, mastering .gitignore is a valuable skill.

Ready to take your DevOps game to the next level? Implement these tips and see the difference!

That’s it, thank you for reading.

I am happy to share this article to help you explore new updates, do follow me, and click the clap 👏 button below to show your valuable support.

Unlocking the Power of .gitignore in Your DevOps Workflow was originally published in Cloudnloud Tech Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

Few of my reference to earlier medium.com article on Docker is shared here below, in case you want to brush your ideas around, here is the references for the same

1. https://lnkd.in/gvvA7car

2. https://lnkd.in/gkZ7gKuz

3. https://lnkd.in/ghkp-6VS

So, it's by now we have the basic setup to start creating the images for the SonarQube/PostrgreSQL using Docker Compose.

Here is the Ubuntu VM created in Azure Cloud

The first thing to do before logging to the VM, enable the port 9000 open in this machine as this is the default port for SonarQube.

Go into the VM, navigate to the Network settings sub tab under Networking tab section and ensure to add the inbound port as shown below

Logged into the VM using SSH mode

The Ubuntu machine is updated and installed with Docker and Vi editor for action (detailed steps are mentioned as per the link shared in prerequisite during the start of this article) and docker installation is confirmed by following command

sudo docker --version

Following configuration details or line is needed and updated to the end of the file /etc/sysctl.conf in superuser mode

vm.max_map_count=262144
fs.file-max=65536

To have the configuration changes to apply immediately without need to restart the machine execute this command as below

sudo sysctl -p

Now let update the system once again and install the docker compose now as below

sudo apt-get update -y
sudo apt-get install docker-compose -y

Let's confirm the installation of docker compose with following command

sudo docker-compose --version

Create the docker-compose.yml file with following YAML for creating the images for SonarQube and PostgreSQL

version: "3"
services:
  sonarqube:
    image: sonarqube:community
    restart: unless-stopped
    depends_on:
      - db
    environment:
      SONAR_JDBC_URL: jdbc:postgresql://db:5432/sonar
      SONAR_JDBC_USERNAME: sonar
      SONAR_JDBC_PASSWORD: sonar
    volumes:
      - sonarqube_data:/opt/sonarqube/data
      - sonarqube_extensions:/opt/sonarqube/extensions
      - sonarqube_logs:/opt/sonarqube/logs
    ports:
      - "9000:9000"
  db:
    image: postgres:12
    restart: unless-stopped
    environment:
      POSTGRES_USER: sonar
      POSTGRES_PASSWORD: sonar
    volumes:
      - postgresql:/var/lib/postgresql
      - postgresql_data:/var/lib/postgresql/data
volumes:
  sonarqube_data:
  sonarqube_extensions:
  sonarqube_logs:
  postgresql:
  postgresql_data:

Use this command to create a file in Vi editor

vi docker-compose.yml

In the Vi editor, use Esc to change to command mode, type :wq to save and exit the editor and ensure the content is saved using cat command as shown below

Execute this command to create the images for SonarQube and PostgreSQL in a detached mode, meaning it will be running in the background by returning to the prompt immediately

sudo docker-compose up -d

Execute the docker-compose log to see the service is active with this command

sudo docker-compose logs --follow

Now use the public ip of the machine and with port 9000 access the SonarQube GUI from the browser client

Login with default username & password (‘admin’ for both) and then try resetting it once logged in for first time

Now we have successfully launched the instance for Sonarqube and its time to integrate or use for static code analysis for the projects in completed stage.

That’s it, thank you for reading.

I am happy to share this article to help you explore new updates, do follow me, and click the clap 👏 button below to show your valuable support.

Build Your Own SonarQube Docker Image for Effortless Static Code Analysis! was originally published in Cloudnloud Tech Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

Pre-requisites: Ensure you have the latest .NET Core software installed on your local Windows machine, a basic understanding of the Windows environment, and fundamental programming knowledge.

Quick Link for .NET Core Download: Download .NET (Linux, macOS, and Windows)

In this article, I will guide you through the steps needed to create your first .NET Core web project in less than 5 minutes, without the need for lengthy video tutorials or extensive reading.

I will cover each step to help you get your web project running locally on your Windows machine.

Let’s begin by logging into your Windows machine and opening the command prompt. For this example, I prefer using the F: drive, which I keep clean for research and learning purposes:

Let's execute the MS-DOS command below to see if anything out there in this drive by chance

dir

There is no file or any content out there and now let's create the new folder for our new Web Project by executing the below MS-DOS command

mkdir DotnetCoreWebApp

Move into the new folder or directory that we created in the above steps as the first action in making our web project solution by executing the below MS-DOS command

cd DotnetCoreWebApp

To begin with, Dotnet core, let's create our first Dotnet solution template that holds all the related projects inside it for easy management with the following commands

dotnet new sln -o DotnetCoreMyFirstWebSln

Now let's kick start the creation of the MVC web project with the execution of the following command

dotnet new mvc -n HelloworldApp.web

This output confirms the creation of our first MVC web project as a folder structure as highlighted above. Since the project was created separately we need to associate it with the solution file for the bind.

Let's add the newly created web project with the solution file as created in earlier steps by executing the following command

dotnet sln DotnetCoreMyFirstWebSln add ./HelloworldApp.web/HelloworldApp.web.csproj

It is time to compile and build the files by executing the following command as below

dotnet build HelloworldApp.web

The project was compiled successfully, and please note we have not written any Dot net program code assuming we don't even know how to write our first Dot net core web project. Let's check a few things after the project compilation by navigating to this folder below

cd HelloworldApp.web/bin/debug/net8.0

.dll file was created on building the project, this is the actual executable needed to execute the dot net mvc web application. Navigate back to the Project folder by executing the below command

cd ../../../

It is time to execute the generated DLL to see our first website project in action as below

dotnet ./bin/debug/net8.0/HelloworldApp.web.dll

Copy the URL as shown above and paste it into the address bar of the web browser to see the website running at the backside

Go back to the command prompt window, and press Ctrl + C to exit from the running mode to return to the prompt.

Hurray our first Dotnet MVC web project has been successfully launched locally on our Windows machine.

Note: Alternatively, you can use the VSCode editor for writing your own application without the command line tool shown above. (Download Link: 1. ARM64: Download Visual Studio Code — Mac, Linux, Windows, 2. X64: Visual Studio Code on Windows)

That’s it, thank you for reading.

I am happy to share this article to help you explore new updates, do follow me, and click the clap 👏 button below to show your valuable support.

How to Create a .NET Core MVC Web Project from Scratch was originally published in Cloudnloud Tech Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

It supports 30+ major programming languages ​​with various plugins. SonarQube is developed using the Java programming language. SonarQube provides integration with various build tools such as Maven, Ant, Gradle, MSBuild, and continuous integration (Azure DevOps, Atlassian Bamboo, Jenkins, Hudson, AWS), etc.

What is SonarQube?

SonarQube is essentially a code quality management platform that provides detailed insights into the health of your codebase. It offers a plethora of features, including:

• Static Code Analysis: Scans your code for potential issues.
• Code Metrics: Measures code complexity, duplication, and test coverage.
• Security Vulnerability Detection: Identifies security risks in your code.
• Code Smell Detection: Highlights areas of the code that need refactoring.

How Does SonarQube Work?

SonarQube analyzes source code through a process called static analysis. Here’s how it works:

• Code Scan: The source code is scanned using SonarQube’s extensive ruleset.
• Issue Detection: The scanner identifies bugs, code smells, and security vulnerabilities.
• Metrics Calculation: Calculates various metrics like code complexity, lines of code, duplications, and test coverage.
• Results Storage: The results are stored in a database for historical tracking and trend analysis.
• Reporting: Generates detailed reports that help developers and teams understand the issues and trends in their code.

When to Use SonarQube?

SonarQube can be used at various stages of software development:

• During Development: Integrate with IDEs to get real-time feedback.
• Code Review: Use in pull request analysis to ensure new code meets quality standards.
• Continuous Integration: Integrate with CI/CD pipelines to automatically analyze code on every build.
• Security Audits: Regular scans to ensure no security vulnerabilities are present in the codebase.

Benefits Compared to Other Tools

SonarQube offers several benefits compared to other code quality tools:

• Comprehensive Analysis: Covers a wide range of programming languages and quality issues.
• Customizability: Allows custom rules, profiles, and plugins to suit specific project needs.
• Integration: Seamlessly integrates with various CI/CD tools and version control systems.
• Open Source: Free to use with a large community for support and plugins.
• Historical Tracking: Keeps a historical record of code quality metrics and issues.

Pros and Cons

Pros:

• Supports multiple languages
• Extensive rule set for code quality and security
• Integrates with CI/CD pipelines
• Customizable quality profiles
• Detailed reports and dashboards

Cons:

• Initial setup and configuration can be complex
• Resource-intensive for large projects
• The learning curve for new users

Conclusion

SonarQube is a powerful tool for ensuring code quality and security. Its ability to integrate seamlessly with various CI/CD tools, including Azure DevOps, makes it an essential tool for modern software development. Whether you’re a small team or a large enterprise, SonarQube offers the flexibility and features needed to maintain high code standards.

That’s it, thank you for reading.

I am happy to share this article to help you explore new updates, do follow me, and click the clap 👏 button below to show your valuable support.

SonarQube: Ensuring Code Quality and Security was originally published in Cloudnloud Tech Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

Let’s break down the steps for setting up MongoDB and Mongo Express application pairs using Docker Compose with fewer Docker CLI commands.

Pre-requisite: Working knowledge of Docker, YAML. Installation of Docker, VIM editor in Ubuntu machines to continue with Docker Compose

Install Docker Compose:

Execute the following command to install Docker Compose:

sudo apt-get install docker-compose -y

Docker Compose simplifies managing multiple containers and configurations.

Create a Docker Compose File (mongo.yaml):

Create a file named mongo.yaml with the following content:

version: '3'
services:
  mongodb:
    image: mongo
    ports:
      - 27017:27017
    environment:
      - MONGO_INITDB_ROOT_USERNAME=admin
      - MONGO_INITDB_ROOT_PASSWORD=password
  mongo-express:
    image: mongo-express
    ports:
      - 8081:8081
    environment:
      - ME_CONFIG_MONGODB_ADMINUSERNAME=admin
      - ME_CONFIG_MONGODB_ADMINPASSWORD=password
      - ME_CONFIG_MONGODB_SERVER=mongodb
    depends_on:
      - "mongodb"

• This YAML file defines two services: mongoDB and mongo-express.

Create MongoDB and Mongo Express Containers:

Execute the following command to start the containers:

sudo docker-compose -f mongo.yaml up

Access Mongo Express Web Interface:

Open your web browser and visit:

http://20.163.193.220:8081

Authenticate using the username “admin” and the password you set earlier.

Note: Once the task is done, press Ctrl+C to stop the containers and return to the prompt.

View Container Status:

Check the status of all containers (including stopped ones):

sudo docker ps -a

Run Containers in Detached Mode:

Start the containers in detached mode (background):

sudo docker-compose -f mongo.yaml up -d

Stop Containers:

To stop the containers, use:

sudo docker-compose -f mongo.yaml stop

Now you have created the containers for Mongodb and MongoExpress and successfully communicate with each other using Docker Compose which creates a default network for communication between two application containers.

That’s it, thank you for reading.

I am happy to share this article to help you explore new updates, do follow me, and click the clap 👏 button below to show your valuable support.

Unlocking MongoDB Deployment with Docker Compose and Mongo Express was originally published in Cloudnloud Tech Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

Let’s break down the steps for setting up MongoDB and Mongo Express using Docker without Docker Compose.

Pre-requisite: Working knowledge of Docker, Docker Network.

Create a Docker Network:

Run the following command to create a network named mongo-network:

sudo docker network create mongo-network

This network will allow communication between the MongoDB container and the Mongo Express container.

List Existing Docker Networks:

Check if the mongo-network was successfully created:

sudo docker network ls

Pull MongoDB and Mongo Express Images:

Pull the official MongoDB and Mongo Express Docker images:

sudo docker pull mongo
sudo docker pull mongo-express

These images will be used to create containers for MongoDB and Mongo Express.

List Available Docker Images:

Verify that the images were downloaded:

sudo docker images

Run MongoDB Container:

Start a MongoDB container with the following command:

sudo docker run -d -p 27017:27017 -e MONGO_INITDB_ROOT_USERNAME=admin -e MONGO_INITDB_ROOT_PASSWORD=password --network mongo-network --name mongodb mongo

• -d: Run the container in detached mode.
• -p 27017:27017: Map port 27017 on the host to the MongoDB container.
• -e MONGO_INITDB_ROOT_USERNAME=admin -e MONGO_INITDB_ROOT_PASSWORD=password: Set the root user credentials.
• --network mongo-network: Connect the container to the mongo-network.
• --name mongodb: Assign the name “mongodb” to the container.

Run Mongo Express Container:

Start a Mongo Express container:

sudo docker run -d -p 8081:8081 -e ME_CONFIG_MONGODB_ADMINUSERNAME=admin -e ME_CONFIG_MONGODB_ADMINPASSWORD=password -e ME_CONFIG_MONGODB_SERVER=mongodb --network mongo-network --name mongo-express mongo-express

• -p 8081:8081: Map port 8081 on the host to the Mongo Express container.
• -e ME_CONFIG_MONGODB_ADMINUSERNAME=admin -e ME_CONFIG_MONGODB_ADMINPASSWORD=password: Set the admin user credentials.
• -e ME_CONFIG_MONGODB_SERVER=mongodb: Specify the MongoDB server hostname.
• --network mongo-network: Connect the container to the same network.
• --name mongo-express: Name the container “mongo-express”.

List Running Containers:

Confirm that both containers are running:

sudo docker ps

Access Mongo Express Web Interface:

Open your web browser and visit:

http://20.163.193.220:8081

Authenticate using the username “admin” and the password you set earlier.

Now you have created the containers for Mongodb and MongoExpress and successfully communicate with each other using Docker CLI.

That’s it, thank you for reading.

I am happy to share this article to help you explore new updates, do follow me, and click the clap 👏 button below to show your valuable support.

Unlocking MongoDB Deployment with Docker and Mongo Express was originally published in Cloudnloud Tech Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

The Evolution of Docker and the Docker Family

Docker is a popular and widely used technology that enables developers to build, run, and deploy applications using containers. Containers are isolated environments that package an application and its dependencies together, making it easier to run the application on any platform. But how did Docker and its family of tools come into existence? What are the benefits and challenges of using Docker? And what are the future trends and opportunities for Docker and container technology? In this article, we will answer these questions and more, as we trace the evolution of Docker from its roots in Linux containers to its current status as a leading platform for cloud-native development.

What are Linux Containers?

Before we dive into Docker, let’s first understand what Linux containers are and how they work. Linux containers are a way of creating isolated environments for processes using features of the Linux kernel, such as namespaces and cgroups. Namespaces provide a way of limiting the visibility and access of a process to certain resources, such as files, network interfaces, and user IDs. Cgroups provide a way of controlling and limiting the amount of resources, such as CPU, memory, and disk I/O, that a process can use. By using namespaces and cgroups, Linux containers can create isolated environments that are similar to virtual machines, but without the overhead of running a separate operating system for each environment. Linux containers have been around for a long time, dating back to the 1970s when the chroot system call was introduced to change the root directory of a process and its children. Since then, several tools and technologies have been developed to improve and extend the concept of Linux containers, such as FreeBSD jails, Linux-VServer, OpenVZ, Solaris Containers, and LXC. These tools and technologies offer different levels of isolation, security, and performance for Linux containers, but they also have some limitations and challenges, such as portability, compatibility, and usability.

How did Docker emerge?

Docker was born in 2013 as an open-source project by Solomon Hykes, who was working at dotCloud, a platform-as-a-service company. Docker was initially based on LXC, which was the most complete and stable implementation of Linux containers at the time. However, Docker soon replaced LXC with its library, libcontainer, which provided a consistent and portable interface for creating and managing Linux containers across different Linux distributions and platforms. Docker also introduced several innovations and features that made Linux containers more accessible and user-friendly, such as:

— Docker images: Docker images are the building blocks of Docker containers. They are layered, read-only templates that contain the application code and its dependencies. Docker images can be created using a Dockerfile, which is a text file that specifies the instructions for building the image. Docker images can also be pulled from or pushed to a Docker registry, which is a centralized repository for storing and sharing Docker images.

— Docker containers: Docker containers are the running instances of Docker images. They are lightweight, isolated, and portable environments that can run the application code and its dependencies. Docker containers can be created, started, stopped, and removed using the Docker CLI or API. Docker containers can also be connected to external networks using Docker networks, which are virtual networks that provide communication and isolation for Docker containers.

— Docker Engine: Docker Engine is the core component of Docker that manages the lifecycle of Docker images and containers. It is a client-server application that consists of a daemon, a REST API, and a CLI. The daemon is the background process that communicates with the Linux kernel and creates and runs Docker containers. The REST API is the interface that allows external applications and tools to interact with the daemon. The CLI is the command-line tool that allows users to interact with the daemon using the REST API. — Docker Compose: Docker Compose is a tool that allows users to define and run multi-container applications using a YAML file. The YAML file specifies the services, networks, and volumes that make up the application. Docker Compose can then create and start the containers for each service using the Docker Engine.

— Docker Swarm: Docker Swarm is a tool that allows users to cluster and orchestrate multiple Docker hosts into a single, logical unit. Docker Swarm can manage the deployment, scaling, and load balancing of Docker containers across the cluster using the Docker Engine. Docker Swarm can also integrate with other tools and platforms, such as Kubernetes, Mesos, and Azure, to provide additional features and capabilities for Docker containers.

What are the benefits and challenges of using Docker?

Docker has revolutionized the way developers build, run, and deploy applications using containers. Docker has several benefits and advantages over traditional methods of software development and delivery, such as:

— Portability: Docker containers can run on any platform that supports Docker, such as Linux, Windows, Mac, or cloud. This means that developers can easily move their applications from one environment to another without worrying about compatibility issues or dependencies.

— Consistency: Docker containers provide a consistent and reproducible environment for applications, regardless of where they run. This means that developers can ensure that their applications behave the same way in development, testing, and production, reducing the risk of bugs and errors.

— Efficiency: Docker containers are more efficient and resource-friendly than virtual machines, as they share the same operating system kernel and do not require a separate operating system for each environment. This means that developers can run more applications on the same hardware, saving time and money.

— Isolation: Docker containers provide a high level of isolation and security for applications, as they limit the visibility and access of each container to its resources and network. This means that developers can protect their applications from interference and attacks from other containers or processes.

— Modularity: Docker containers promote a modular and microservice-based architecture for applications, as they allow developers to break down their applications into smaller and independent units that can communicate with each other. This means that developers can improve the scalability, reliability, and maintainability of their applications, as well as the speed and frequency of their updates and releases.

However, Docker also has some challenges and limitations that developers need to be aware of and address, such as:

— Complexity: Docker introduces a new layer of complexity and abstraction for applications, as developers need to learn and use new tools and concepts, such as Dockerfiles, images, containers, networks, volumes, registries, and orchestration. This means that developers need to invest time and effort to master Docker and its ecosystem, as well as to troubleshoot and debug any issues that may arise.

— Security: Docker containers are not inherently secure, as they rely on the security of the underlying operating system and kernel, as well as the configuration and management of the containers and their resources. This means that developers need to follow best practices and guidelines to secure their Docker containers and their applications, such as using trusted images, scanning for vulnerabilities, applying patches and updates, enforcing policies and rules, and monitoring and auditing the container activity.

— Performance: Docker containers may have some performance overhead and trade-offs compared to native processes, as they involve additional layers and components, such as the Docker daemon, the Docker API, and the Docker network. This means that developers need to optimize and tune their Docker containers and their applications, such as using appropriate resource limits, avoiding unnecessary layers, and choosing the right storage and network drivers.

What are the future trends and opportunities for Docker and container technology?

Docker and container technology have come a long way since their inception, and they continue to evolve and improve with new features and capabilities. Some of the future trends and opportunities for Docker and container technology include:

— Standardization: Docker and container technology are becoming more standardized and interoperable, as they adopt and follow common specifications and standards, such as the Open Container Initiative (OCI) and the Cloud Native Computing Foundation (CNCF). These initiatives aim to provide a consistent and open framework for container formats, runtimes, and platforms, as well as to foster collaboration and innovation among the container community and industry.

— Integration: Docker and container technology are becoming more integrated and compatible with other technologies and platforms, such as serverless, edge, and hybrid cloud. These technologies and platforms offer new and exciting possibilities and use cases for Docker and container technology, such as enabling faster and cheaper development and deployment, extending the reach and availability of applications, and providing more flexibility and choice for developers and users.

— Automation: Docker and container technology are becoming more automated and intelligent, as they leverage and incorporate artificial intelligence and machine learning. These technologies can help Docker and container technology to achieve higher levels of efficiency, reliability, and security, as well as to provide more insights and recommendations for developers and users. For example, they can help optimize resource allocation and utilization, detect and prevent anomalies and threats, and suggest the best practices and solutions for Docker and container technology.

Conclusion

Docker and container technology have transformed how developers build, run, and deploy applications using containers. They have also created a vibrant and dynamic ecosystem of tools and platforms that support and enhance Docker and container technology. However, Docker and container technology have challenges and limitations, and they require careful and proper planning and implementation to achieve the best results. Moreover, Docker and container technology are constantly evolving and improving, and they offer new and exciting opportunities and possibilities for the future of software development and delivery.

That’s it, thank you for reading.

I am happy to share this article to help you explore new updates, do follow me, and click the clap 👏 button below to show your valuable support.

Unlocking the Power of Docker: Evolution, Benefits, and Future Trends was originally published in Cloudnloud Tech Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

Tim Berners-Lee: The Father of HTML

Tim Berners-Lee, an English computer scientist, is credited with inventing the World Wide Web. He introduced HTML, the URL system, and HTTP. His groundbreaking work at CERN in 1990 laid the foundation for the web as we know it today. Berners-Lee’s contributions continue to shape the digital landscape, and he remains an influential figure in technology.

HTML Evolution and the Document Object Model (DOM)

Introduction

The web has come a long way since its inception. Understanding the evolution of HTML and the role of the Document Object Model (DOM) is essential for anyone venturing into web development. In this article, we’ll explore the journey of HTML, delve into the DOM, and discuss its architecture.

HTML Evolution

HTML Basics: HTML (Hypertext Markup Language) is the backbone of the web. It started as a simple markup language for structuring documents, defining headings, paragraphs, and links

HTML2: Introduced in the early ’90s, HTML2 brought essential features like forms. Forms allowed users to input data on web pages, paving the way for interactive content.

HTML3: HTML3, proposed by Tim Berners-Lee in 1991, expanded HTML’s capabilities. Notable features included:

• Customized Lists: Fine-tuned lists with entities like &emspace;.
• Text Flow Around Figures: Text could flow around floating figures.
• Mathematical Equations: Inspired by TeX, HTML3 supported equations.
• Static Banner Area: For corporate logos, disclaimers, and customized navigation.

HTML4 and XHTML: HTML4 introduced more elements and attributes, making it more versatile. XHTML (Extensible HTML) aimed for stricter syntax rules but didn’t gain widespread adoption due to complexity.

HTML5: HTML5 revolutionized the web. It brought new semantic elements (like <header>, <nav>, and <article>), multimedia support (audio and video), and APIs (like Geolocation and Web Storage). HTML5 made web development more expressive and interactive.

The History of the DOM

The Document Object Model (DOM) allows programming languages (primarily JavaScript) to interact with the underlying structure of a web document. Here’s a brief history:

Early Days: In the early web, browsers rendered HTML directly. There was no standardized way to manipulate page content dynamically.

DOM Emerges: The World Wide Web Consortium (W3C) introduced the DOM to bridge this gap. It provided a hierarchical representation of HTML documents, enabling developers to access, modify, and manipulate elements programmatically.

DOM Levels:

DOM Level 1 (1998): Basic access to document elements.

DOM Level 2 (2000): Introduced events, CSS manipulation, and more.

DOM Level 3 (2004): Enhanced support for XML and XPath.

Modern DOM: Today, the DOM is an integral part of web development. It allows us to:

Access elements using document.getElementById(), querySelector(), etc.

Change content, attributes, and styles dynamically.

Add or remove elements on the fly.

DOM Architecture

The DOM is a tree-like structure:

• Document Node: Represents the entire HTML document.
• Element Nodes: Represent HTML elements (e.g., <div>, <p>).
• Attribute Nodes: Hold element attributes (e.g., class, id).
• Text Nodes: Contain text within elements.

So, what is HTML?

HTML, or Hypertext Markup Language, is a markup language for the web that defines the structure of web pages.

HTML determines the structure of web pages. Other technology stack like CSS, Javascript is used with HTML to convert the page to stylish, interactive and dynamic style.

Conclusion

Understanding the evolution of HTML and the power of the DOM is crucial for web developers. As you embark on your journey, remember that the DOM empowers you to create dynamic, interactive web experiences.

That’s it, thank you for reading.

Happy to share this article to help you to explore new updates, do follow me, click the clap 👏 button below to show your valuable support.

HTML Evolution to DOM Mastery: A Web Developer’s Journey was originally published in Cloudnloud Tech Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

Refer my earlier article here for basic understanding of Azure Cloud Shell (Bash).

To access the Azure CLI on a local Linux (Ubuntu distribution or Debian distribution) machine, simply install the Azure CLI on your computer and run it from the command line. This will give you access to all the same features and functionality as the web portal, but with the added convenience of being able to work directly from your local machine.

Let see what the procedure is or step by step instruction needed to set up the Azure CLI (Bash) in local Linux distribution machine. First let check if there exists any version earlier or not from the following command

az --version

The output confirms the azure cli (Bash) was not available earlier in the local Linux distribution machine. Now let see the step-by-step instructions to complete the installation for azure cli and there are 2 options for convenience.

Option 1:

Download the script using following command and send to the bash as shown below:

curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

Option 2:

Update the system and get the packages for the installation

sudo apt-get update
sudo apt-get install ca-certificates curl apt-transport-https lsb-release gnupg

Download and install the key for Microsoft

sudo mkdir -p /etc/apt/keyrings
curl -sLS https://packages.microsoft.com/keys/microsoft.asc |
    gpg --dearmor |
    sudo tee /etc/apt/keyrings/microsoft.gpg > /dev/null
sudo chmod go+r /etc/apt/keyrings/microsoft.gpg

Include the Azure CLI repo

AZ_DIST=$(lsb_release -cs)
echo "deb [arch=`dpkg --print-architecture` signed-by=/etc/apt/keyrings/microsoft.gpg] https://packages.microsoft.com/repos/azure-cli/ $AZ_DIST main" |
    sudo tee /etc/apt/sources.list.d/azure-cli.list

Now update the machine again and install the CLI

sudo apt-get update
sudo apt-get install azure-cli

Now again verify the Azure CLI (Bash) is reflecting in the system as before

The Azure CLI version 2.58.0 has been successfully installed on the local system. Upon inspection, you may observe the installation of additional dependencies, as well as the default Python version 3.11.7.

How to Upgrade Azure CLI if already installed?

This following command updates all installed extensions as required.

az upgrade

That’s it, thank you for reading.

Happy to share this article to help you to explore new updates, do follow me, click the clap 👏 button below to show your valuable support.

Configure Azure CLI locally in Linux Distribution (Ubuntu or Debian) and enjoy Commands. was originally published in Cloudnloud Tech Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

Prerequisite: Need an Ubuntu machine with Docker installed.

Refer my article for installing Docker in Ubuntu machine: https://shorturl.at/6oJ7w

Let's quickly create a personalize webpage and once it was dockerised we will try adding more lights to the webpage.

Here is my quick webpage content for my index.html file:

<html>
<body>
<h1>Welcome to Hello World! </h1>
</body>
</html>

Assume you have the Ubuntu machine and Docker installed and here is the reference to my earlier medium.com article for quick or easy reference:

Unlock the Power of Docker: Easy Step-by-Step Installation Guide for Ubuntu Users!

Login to the Ubuntu machine and create a working folder DockerFolder and move into this new folder

Create an index.html inside this new folder using the vi editor as below:

Note: Incase if vi editor not available by default in Ubuntu, try use the below commands for clean and quick install

sudo apt-get update
sudo apt-get install vim -y

It's time to create a simple Dockerfile (Please note the file and it should be of this name as best practice) for containerizing the Ubuntu base image with apache2 webserver with the customized webpage to the root folder as below:

FROM ubuntu
ENV DEBIAN_FRONTEND=noninteractive
RUN apt-get update -y
RUN apt-get install apache2 -y
COPY ./index.html /var/www/html

Next to build this file to create an image by executing the following command

sudo docker build . -t bsrinivasancbe/apachehelloworld2024

This command will execute the configuration details in the current folder with the file named Dockerfile and an image will be created with the name “bsrinivasancbe/apachehelloworld2024”

Execute the following command to list out all the docker images in the current directory

sudo docker images

Now the image needs to be executed to create the instance namely container as below:

sudo docker run -it -p 80:80 -d bsrinivasancbe/apachehelloworld2024

Also to list all the active containers in the current directory, execute the following command:

sudo docker ps

Hurray! you have created the docker container running on port 80 in an easy peasy steps!

Let say we want to verify the container in action, then we have to perform 2 more actions namely: enable the port 80 for the VM and start the Apache ser

vice by logging into the container as below:

To login to the running container execute the below docker command with <<containerid>> replaced with actual containerid that is listed from the above command

sudo docker exec -it <<containerid>> bash

To check the Apache service is running inside the container, execute following command to verify

service apache2 status

To start the Apache service execute the below command and again check with above command to see the service got started now.

service apache2 start

Once done exit from the container by executing the below command

exit

Now traverse to the browser and access the Public IP of the VM to see the web page getting accessed as below

Since our scope is done, let's do some clean up as best practices by stopping the container and removing from the VM machine from the following commands set:

sudo docker stop <<container_id>>

sudo docker rm <<container_id>>

Then we can delete the images by referring the image id as below

sudo docker rmi <<image_id>>

That’s it, Thank you for reading, Happy Dockerising!

Happy to share this article to help you to explore new updates, do follow me in medium.com, click the clap 👏 button below to show your valuable support.

Dockerise the simple customized website — Step by step implementation was originally published in Cloudnloud Tech Community on Medium, where people are continuing the conversation by highlighting and responding to this story.