Forem: Onyeanuna prince

Introduction to Multi-Cluster Deployment in Kubernetes

Onyeanuna prince — Fri, 09 Aug 2024 09:05:36 +0000

When starting out with Kubernetes, you've probably used a single cluster architecture. This architecture is easy to set up and allows you to enjoy the benefits of scaling and deploying your applications. If you've used this setup for a long time and on much larger projects, then you must have started to notice the cracks in this architecture.

As your project grows, you'll start to notice specific bottlenecks of a single Kubernetes cluster architecture. These bottlenecks include resource constraints, fault isolation, geographic distribution, and others. However, there's a solution—multi-cluster architecture.

In this article, you'll understand how multi-cluster architecture in Kubernetes solves these bottlenecks and why it's important. In the end, you'll have the right amount of information to help you decide whether to use a single or multi-cluster architecture in your project.

What are Kubernetes multi-clusters?

Multi-clusters in Kubernetes are the deployment of several clusters across different data centres or cloud regions. In terms of your application, it means using more than one Kubernetes cluster to deploy and manage your product.

A multi-cluster setup can really come in handy when looking to offer optimum uptime. By distributing your application across multiple clusters, you can ensure that your services remain available even if one cluster experiences a failure.

Why do you need multiple clusters?

There are some reasons why most engineers consider using a multi-cluster architecture. Below are some of these reasons:

Scalability

With multi-cluster setups, you can better distribute your resources across several clusters. This makes it possible to scale your application more effectively to take on higher traffic and prevent any cluster from becoming a bottleneck.

Reduced blast radius

Blast radius refers to the extent of impact that a failure in one part of a system can have on the rest of the system. It measures how far-reaching the consequences of an incident can be. By relying on a multi-cluster architecture, you ensure that only a limited part of your system gets affected in the event of an outage or security breach.

Geographical redundancy and disaster recovery

Deploying your clusters in different geographical regions ensures that your application can withstand regional failures, such as natural disasters or network outages. This geographical spread also ensures quick failover and data recovery from unaffected clusters.

Reduced latency

When you place several clusters close to end-users, you greatly reduce the time it takes to process requests on your applications. This is particularly beneficial for global applications that serve users from various locations around the world.

Isolation

Rather than using namespaces in a single Kubernetes cluster, multi-clusters can provide better isolation for various development stages (development, testing, production). This isolation method enhances security by reducing the risk of cross-environment contamination and unauthorized access.

Operational flexibility

When performing maintenance, updates, or any scaling operation, you can decide to carry it out on any one of your clusters. This ensures that you're not affecting the entire system. This flexibility offers smoother operations and less disruption to services.

What does a multi-cluster architecture look like?

In practice, let's say you're working on a project, and you want to use a multi-cluster architecture for it. You can use any method of provisioning your Kubernetes clusters, but in this case, you're relying on Amazon Elastic Kubernetes Service (EKS) and Google Kubernetes Engine (GKE).

Figure 1: Multi-cluster architecture between AWS and GCP

First, you start by provisioning the EKS cluster in AWS and the GKE cluster in Google Cloud. Both clusters are fully functional Kubernetes environments set up in their respective cloud providers.

Next, to enable communication between the clusters, you can set up VPN connections between the AWS VPC and the Google Cloud VPC. This establishes a secure link that allows the clusters to communicate with each other.

After this, you'll install Cilium as the networking plugin (CNI) on both the EKS and GKE clusters. This involves installing Cilium's agents and configuring the clusters to use Cilium for networking. At this point, Cilium doesn't bother about how both clusters are connected but rather if their endpoints are reachable.

You can then configure Cilium's cluster mesh feature, which will integrate the clusters into a single, unified network. This involves configuring Cilium to recognize the other cluster and allowing services and pods in the EKS cluster to communicate seamlessly with those in the GKE cluster.

Finally, you'll deploy applications or services across the clusters and verify that they can interact as expected. With Cilium's cluster mesh, your EKS and GKE clusters are now interconnected, and your multi-cluster setup should work perfectly.

When to use a multi-cluster architecture

Depending on your organization's goals or your application's requirements, you must consider certain measures when choosing your product's architecture.

High availability

Let's say the primary goal of your application - as it is with 100% of other products - is to offer maximum uptime and remain operational even during regional outages or disasters.

In this case, you can consider deploying clusters in multiple geographical regions to ensure that if one cluster goes down, others can take over, providing uninterrupted service.

Geographical distribution

If you already have a large organization with a global user base or you're growing quickly, you can minimize latency by serving users based on location.

By setting up clusters in various regions much closer to your users, you reduce latency and improve the user experience by routing traffic to the cluster closest to them.

Workload segmentation

If your application has unique requirements for its resources, security, or infrastructure, you can use distinct clusters to cater to the specific needs of different workloads. For instance, you can separate machine learning workloads from standard web applications.

Cross-cloud strategy

Let's say your organization currently relies on multiple cloud providers for specific reasons, such as preventing vendor lock-in, utilizing specific resources, or ensuring redundancy. You can consider deploying your clusters across the different cloud providers to leverage each provider's best features.

Conclusion

In this article, we defined a multi-cluster and showed how its architecture works in practice. We also discussed some reasons why you might consider using it and what to look out for when making your choice.

Always remember that a multi-cluster architecture is handy when you need to ensure high availability, minimize latency, and perform maintenance without downtime.

Monitoring, Observability, and Telemetry Explained

Onyeanuna prince — Tue, 02 Apr 2024 19:39:44 +0000

This article was originally posted on EverythingDevOps.

Whenever something goes wrong in a system or application, it affects the customers, the business performance, and of course, the Site Reliability Engineers (SREs) who stay up late to fix it.

While engineers often use terms/tools such as monitoring, observability, and telemetry interchangeably, they aren't the same things. Monitoring sets triggers and alerts that go off when an event occurs, Telemetry gathers system data, and Observability lets you know what's going on in the system.

The trio is responsible for quickly restoring downtime within organizations; however, to utilize them effectively, you need to understand their significant differences and how they work together. By the end of this article, you will have a clear understanding of how each concept works and how they can be combined to ensure your system is reliable.

What is Monitoring?

After deploying an application, to ensure that there are little to no downtimes, several post-deployment practices are put in place. One of such practices is monitoring.

Monitoring can be defined as the continuous assessment of a system's health and performance to ensure that it is running as expected. With monitoring, you don't have to wait for a customer to report an issue before you know that something is wrong. Its triggers and alerts are set to go off when an event occurs.

In monitoring, you define what "normal" means for your system and set up alerts to notify you when the system deviates from that normal state. For example, you could set up an alert to notify you when the CPU usage of your server exceeds 80%. This way, you can take action before the server crashes.

Monitoring not only gives you an insight into the health of your system but also helps you to identify trends and patterns in the system. This helps you know how the application has been used over time and makes it easier to predict future issues.

Types of Monitoring

Although the concept of monitoring stays the same, its application differs. This difference is due to the diverse nature of IT environments, the complexity of systems, varied use cases, and emerging technologies and trends.

There are different types of monitoring, each designed to monitor a specific aspect of the system. Some of these types include:

Application Performance Monitoring (APM): APM focuses on monitoring the performance and availability of software applications. It involves tracking metrics related to response times, throughput, error rates, and resource utilization within the application. APM tools provide real time insights into application bottlenecks, code inefficiencies, and user experience issues.

Infrastructure Monitoring: This type of monitoring focuses on the health and performance of physical and virtual infrastructure such as servers, networks, and storage. It includes monitoring the CPU utilization, memory usage, disk space, and network bandwidth to ensure optimal performance.

Network Monitoring: It involves monitoring the performance of network infrastructure and traffic. It includes the monitoring of devices such as routers, switches, firewalls, and load balancers, as well as the analysis of network traffic patterns, packet loss, latency, and bandwidth utilization. Network monitoring helps ensure optimal network performance, troubleshoot connectivity issues, and detect security threats.

Log Monitoring: Log monitoring involves collecting, analyzing, and correlating log data generated by systems, applications, and devices. It helps organizations track system events, troubleshoot issues, and ensure compliance with regulatory requirements. Log monitoring tools provide centralized log management, real-time alerting, and advanced analytics capabilities to facilitate log analysis and investigation.

Security Monitoring: This type of monitoring focuses on detecting and responding to security threats and vulnerabilities. It involves monitoring network traffic, system logs, and user activities to identify suspicious behaviour, unauthorized access, and security breaches. Security monitoring tools provide real-time threat detection, incident response, and security analytics capabilities to help organizations protect their sensitive data.

Cloud Monitoring: Cloud monitoring involves monitoring the performance and availability of cloud-based infrastructure and services. It includes monitoring cloud resources such as virtual machines, storage, databases, and containers, as well as tracking cloud service metrics provided by cloud service providers (CSPs). Cloud monitoring helps organizations optimize cloud resource utilization, manage costs, and ensure service uptime and reliability.

End-User Monitoring (EUM): This type of monitoring focuses on tracking the experience of end-users interacting with applications and services. It involves measuring metrics such as page load times, transaction completion rates, and user interactions to assess application performance from the end-user perspective. EUM tools provide insights into user behaviour, application performance, and service availability to help organizations deliver a seamless end-user experience.

What's the Problem with Legacy Monitoring?

The term "legacy" refers to outdated systems, technologies, or practices that are no longer efficient or effective. Legacy monitoring is the traditional approach to monitoring that is no longer sufficient for modern IT environments.

The problem with legacy monitoring is that it is not designed to handle the complexity, scale, and dynamism of modern systems and applications. Legacy monitoring tools are often siloed, inflexible, and unable to provide the level of visibility and insights required to manage modern IT environments effectively.

Some of the challenges associated with legacy monitoring include:

Lack of Scalability: Legacy monitoring systems often lack scalability to handle the growing volume, variety, and velocity of data generated by modern IT infrastructure and applications. As organizations scale their operations and adopt new technologies, legacy systems may struggle to keep up, leading to performance degradation and gaps in monitoring coverage.

Limited Visibility: Legacy monitoring tools provide limited visibility into the complex interactions and dependencies within modern IT ecosystems. They often focus on monitoring individual components in isolation, rather than providing holistic insights into system behavior and performance across the entire technology stack. This limited visibility hampers the ability to detect and diagnose issues that span multiple layers of the infrastructure.

Limited support and updates: Legacy monitoring systems are often inflexible and difficult to adapt to changing business requirements, technologies, and use cases. They may lack support for modern deployment models such as cloud computing, containerization, and microservices, making it challenging to monitor dynamically orchestrated environments effectively.

Inadequate Security Monitoring: Legacy monitoring systems may lack robust security monitoring capabilities to detect and respond to cybersecurity threats effectively. As cyberattacks become more sophisticated and targeted, organizations require advanced security monitoring tools that can analyze large volumes of security data in real time and provide actionable insights to mitigate risks.

A Historical Overview of Monitoring and Observability

Since the advent of computing technology and IT management practices over the past decade, monitoring and observability have also evolved. During the early days of computing, primitive monitoring tools focused on hardware components, paving the way for more sophisticated monitoring tools during the mainframe era.

With the popularity of computer networks, network management protocols like SNMP became available, enabling administrators to monitor and manage network resources. The growth of enterprise IT environments, platforms like HP OpenView and IBM Tivoli emerged, providing centralized monitoring and management capabilities for diverse infrastructures.

In the 2000s, as web-based applications and distributed architectures became increasingly popular, Application Performance Management (APM) solutions emerged, monitoring software applications and user experiences.

In 2010, cloud computing and DevOps practices revolutionized IT operations, introducing new challenges and opportunities for monitoring and observability. The development of cloud-native monitoring and DevOps tools enabled organizations to monitor dynamic environments using features such as infrastructure-as-code and containerization. Additionally, observability emerged, emphasizing the importance of understanding system behaviour from rich telemetry and contextual information.

In this way, observability platforms provided insights into complex systems that allowed troubleshooting, debugging, and optimization to be easily accomplished. From early hardware monitoring to modern observability platforms, IT infrastructure and applications have been continually monitored and controlled to gain greater visibility, insight, and control.

Why Observability?

Observability refers to the ability to understand and analyze the internal state of a system based on its external outputs or telemetry data. Observable systems allow users to find the root cause of a performance issue by inspecting the data they generate.

By implementing telemetry-producing tools in systems, you can gather comprehensive data about the system's interactions, dependencies, and performance. Through correlation, analysis, visualization, and automation, observability platforms provide meaningful insights based on this data.

Differences between Observability and Monitoring

The distinction between observability and monitoring lies in their focus, approach, and objectives within IT operations.

Monitoring primarily involves the systematic continuous collection and analysis of predefined metrics and thresholds to track the health, performance, and availability of systems, applications, or services. It operates on the principle of setting triggers and alerts to signal deviations from expected behaviour, enabling reactive management and troubleshooting.

Observability, on the other hand, shifts the focus from predefined metrics to gaining a deeper understanding of system behaviour and interactions. It emphasizes the need for rich, contextual data and insights into the internal state of a system, captured through telemetry data. Observability enables organizations to explore and analyze system behaviour in real time, facilitating troubleshooting, debugging, and optimization efforts.

While monitoring focuses on predefined metrics to track system health and performance, observability emphasizes the need for telemetry data of the system's behaviour to facilitate deeper understanding and analysis. Monitoring is reactive, while observability is proactive, empowering organizations to detect, diagnose, and resolve issues more effectively in complex distributed systems.

A Brief Intro to Telemetry Data

Telemetry data refers to the collection of measurements or data points obtained from remote or inaccessible systems, devices, or processes. This data typically includes information about the operational status, performance metrics, logs, and behaviour of these systems.

The role of telemetry data is to provide insights into how systems operate, how they interact with each other, and how they perform over time. By analyzing telemetry data, organizations can gain a deeper understanding of their systems, identify patterns, detect anomalies, and make informed decisions to optimize performance, enhance reliability, and troubleshoot issues effectively.

Comparisons and Relationships

Monitoring focuses on tracking the health and performance of systems through predefined thresholds. It typically involves collecting metrics related to system resource utilization, response times, error rates, and other key performance indicators (KPIs). Monitoring provides a high-level view of system health and performance, alerting operators to potential issues or deviations from expected behaviour.

Telemetry focuses on collecting data such as logs, metrics, and traces from systems, especially in dynamic cloud environments. While telemetry provides robust data collection and standardization, it lacks the deep insights needed for quick issue resolution.

Observability goes beyond telemetry by offering analysis and insights into why issues occur. It provides detailed, granular views of events in an IT environment, enabling custom troubleshooting and root cause analysis.

APM, while similar to observability, focuses specifically on tracking end-to-end transactions within applications. It offers high-level monitoring of application performance but may not provide the technical details needed for deep analysis.

Overall, telemetry and APM provide monitoring capabilities while observability offers deeper insights into system behaviour and performance, enabling effective troubleshooting and analysis across IT infrastructure.

The Transition from Monitoring to Observability

Imagine a company that operates an e-commerce platform. In the past, they could rely solely on traditional monitoring tools to track the health and performance of their system. These tools would provide the basic metrics such as CPU usage, memory utilization, and response times for their web servers and databases.

However, as their platform grows in complexity and scale, they might frequently encounter issues that traditional monitoring tools can no longer address adequately. For example, during a high-traffic event like a flash sale, they could notice occasional spikes in latency and occasional errors occurring in their checkout process. While they can see these issues occurring, they will struggle to pinpoint the root cause using traditional monitoring alone.

To address these challenges, this company must adopt observability practices. By implementing telemetry solutions that collect a broader range of data, including detailed logs, distributed traces, and custom application metrics. With this richer dataset, they'll gain deeper insights into their system's behaviour and performance.

They can now trace individual requests as they flow through their microservices architecture, allowing them to identify bottlenecks and latency issues more effectively. They can also correlate application logs with system metrics to understand how the changes in application code affect the overall system health.

By transitioning to observability, this company gains a more comprehensive understanding of its system's behaviour and performance. They can proactively identify and resolve issues, leading to improved reliability and a better user experience for their customers.

Choosing the Right Tool

Choosing the right observability tool is crucial for ensuring the reliability of modern software systems. Below are key factors to consider when selecting an observability tool for your organization:

Data Collection: Look for a tool capable of collecting and aggregating data from various sources like logs, metrics, and traces - the three pillars of observability. Before choosing a tool, ask yourself, "Can this tool handle the diverse data sources present in our infrastructure, and can it process high volumes of data in real time?" Example tools include Datadog, Splunk, and New Relic.

Visualization and Analysis: Choose a tool with intuitive and customizable dashboards, charts, and visualizations. A question to ask is, "Are the visualization features of this tool user-friendly and adaptable to our team's specific needs?" Tools like Grafana and Kibana provide powerful visualization capabilities.

Alerting and Notification: Select a tool with flexible alerting mechanisms to proactively detect anomalies or deviations from defined thresholds. Consider asking questions like "Does this tool offer customizable alerting options and support notification channels that suit our team's communication preferences?" A tool like Prometheus provides robust alerting capabilities.

Scalability and Performance: Consider the scalability and performance capabilities, especially if your organization handles large volumes of data or has a growing user base. Ask yourself, "Is this tool capable of scaling with our organization's growth and maintaining performance under increased data loads?" You can utilize a tool like InfluxDB for scalable time-series data storage.

Integration and Compatibility: Assess compatibility with your existing software stack, including infrastructure, frameworks, and programming languages. To make this assessment, ask yourself, "Does this tool seamlessly integrate with our current technologies and support the platforms we use, such as Kubernetes or cloud providers?" Most observability tools are open-source and support a wide range of integrations.

Extensibility and Customization: Evaluate the tool's extensibility to incorporate custom instrumentation and adapt to specific application requirements. Ask yourself, "Can we easily extend the functionality of this tool through custom integrations and configurations to meet our unique monitoring needs?"

By considering these questions, you can make a more informed decision when selecting an observability tool for your organization.

Conclusion

This article has explored the vital aspects of observability and monitoring in modern IT operations. It covered the role of telemetry data, compared observability with related concepts, illustrated the transition from traditional monitoring to observability, and discussed key factors in selecting observability tools.

Throughout, we've emphasized the importance of balancing monitoring and observability for efficient IT operations, highlighting how a comprehensive approach can provide deep insights and enhance system reliability in today's dynamic digital landscape.

By understanding the differences between monitoring, observability, and telemetry, and by leveraging the right tools and practices, DevOps teams can gain a deeper understanding of their systems, proactively identify and resolve issues, and optimize performance to deliver a seamless user experience.

How to Setup a Kubernetes Cluster with Minikube

Onyeanuna prince — Tue, 06 Feb 2024 05:58:08 +0000

For users that are interested in trying out Kubernetes or developing with it on a regular basis, Minikube runs a single-node Kubernetes cluster in a VM on their laptop.

With Minikube, new Kubernetes developers can master the basics, try out new ideas, and become familiar with the Kubernetes environment.

Rather than using a cloud-based Kubernetes cluster, Minikube allows you to run Kubernetes on local machines. This is useful for testing and development purposes, as well as for learning Kubernetes concepts and features.

In this tutorial, you will learn how to set up a Kubernetes cluster on a local machine.

Prerequisites

Although this tutorial will explain each process in detail, it is recommended that you have a basic understanding of Kubernetes and its concepts.

You will also need to have the following installed on your local machine:

Docker: Docker acts as the container runtime and provides the necessary infrastructure for Minikube to create and manage containers within the local Kubernetes cluster.
Kubectl: This is the command-line tool used to interact with the local Kubernetes cluster created by Minikube. It allows you to run commands against Kubernetes clusters to deploy applications, inspect and manage cluster resources, and view logs.
Hardware requirements: Minikube requires a minimum of 2 CPUs, 2GB of RAM, and 20GB of disk space to run a single-node Kubernetes cluster.

Step 1 — Installing Minikube

The OS used in this tutorial is Ubuntu 20.04, but you can install Minikube on other operating systems as well.

Installing Minikube requires downloading the Minikube binary and installing it on your local system.

Minikube has binary versions for many operating systems and architectures. You can find the binary for any system type by checking the Minikube releases page.

To find out your system architecture type, run the following command:

uname -i

To download the Minikube binary for a x86_64 architecture Ubuntu system, run the following command:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb

sudo dpkg -i minikube_latest_amd64.deb

The output will look like this:

Selecting previously unselected package minikube.
(Reading database ... 65066 files and directories currently installed.)
Preparing to unpack minikube_latest_amd64.deb ...
Unpacking minikube (1.32.0-0) ...
Setting up minikube (1.32.0-0) ...

Run the following command to verify that Minikube has been installed:

minikube version

Step 2 — Starting Minikube

When you start Minikube, it creates a single-node Kubernetes cluster inside a VM on your local machine.

In this case, Minikube will use the Docker container runtime to create and manage containers within the local Kubernetes cluster.

To start Minikube, run the following command:

minikube start

The output will look like this:

😄  minikube v1.32.0 on Ubuntu 22.04
✨  Automatically selected the docker driver. Other choices: none, ssh
📌  Using Docker driver with root privileges
👍  Starting control plane node minikube in cluster minikube
🚜  Pulling base image ...
💾  Downloading Kubernetes v1.28.3 preload ...
    > preloaded-images-k8s-v18-v1...:  403.35 MiB / 403.35 MiB  100.00% 138.82
    > gcr.io/k8s-minikube/kicbase...:  453.90 MiB / 453.90 MiB  100.00% 140.38
🔥  Creating docker container (CPUs=2, Memory=7900MB) ...
🐳  Preparing Kubernetes v1.28.3 on Docker 24.0.7 ...
    ▪ Generating certificates and keys ...
    ▪ Booting up control plane ...
    ▪ Configuring RBAC rules ...
🔗  Configuring bridge CNI (Container Networking Interface) ...
    ▪ Using image gcr.io/k8s-minikube/storage-provisioner:v5
🔎  Verifying Kubernetes components...
🌟  Enabled addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default

To check the status of the Minikube cluster, run the following command:

minikube status

This will show you the status of the Minikube cluster:

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

This status simply shows that the Minikube cluster is running and the Kubernetes components are up and running.

Step 3 — Interact with the Kubernetes Cluster

At this point, Minikube has started a single-node Kubernetes cluster inside a VM on your local machine.

It also configured the Kubernetes command-line tool, kubectl, to interact with the local Kubernetes cluster.

To view the nodes in the cluster, run the following command:

kubectl get nodes

You should see only one node - the Minikube node:

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   77s   v1.28.3

Step 4 — Deploy an Application

Now that you have a running Kubernetes cluster, you can deploy an application to it.

This tutorial will deploy a Kubernetes sample application called hello-minikube.

This application is a simple web server that serves a static web page containing the text "Hello, Minikube!".

To deploy the hello-minikube application, run the following command:

kubectl create deployment hello-minikube --image=k8s.gcr.io/echoserver:1.10

The command will create a deployment called hello-minikube and use the k8s.gcr.io/echoserver:1.10 image to create the pods.

Step 5 — Expose the Deployment

Exposing a deployment means making it accessible from outside the Kubernetes cluster.

To expose the hello-minikube application, run the following command:

kubectl expose deployment hello-minikube --type=NodePort --port=8080

This command creates a service of type NodePort that exposes the hello-minikube deployment on a port accessible from outside the cluster.

Step 6 — Access the Application

To access the hello-minikube application, you need to find the URL to access the service.

To find the URL, run the following command:

minikube service hello-minikube --url

The output will look like this:

http://<ip>:<port>

You can access the application by visiting the URL in your web browser.

You can also use the curl command to access the application from the terminal.

curl http://<ip>:<port>

Step 7 — Stopping Minikube

When you are done working with the Minikube cluster, you can stop it by running the following command:

minikube delete

The output will look like this:

🔥  Deleting "minikube" in docker ...
🔥  Deleting container "minikube" ...
🔥  Removing /home/ubuntu/.minikube/machines/minikube ...
💀  Removed all traces of the "minikube" cluster.

This command will stop the Minikube cluster and remove all traces of it from your local machine.

Conclusion

In this tutorial, you learned how to set up a Kubernetes cluster on your computer with Minikube.

You also learned how to deploy an application to the cluster and access it from outside the cluster.

Your journey with Kubernetes has just begun. You are now ready to explore more advanced Kubernetes and Minikube features.

How to Containerize an Application with Docker

Onyeanuna prince — Tue, 30 Jan 2024 09:37:13 +0000

Containerizing an application involves packaging it with its dependencies and configuration files. This enables it to run seamlessly in any environment.

This step is crucial in the development process because it allows developers to concentrate on the application itself rather than the environment in which it will operate.

Additionally, it enables the application to deploy in any environment without concerns about dependencies and configurations.

In this article, you'll learn how to write a Dockerfile to containerize a simple frontend weather application.

Prerequisites

While this tutorial will detail each step, it's recommended that you have the following:

Docker installed on your machine. You can find installation instructions for various platforms on the Docker website.
A fundamental understanding of Docker. If you're new to Docker, you can explore the Docker Documentation for a quick introduction.

Overview

For simplicity, this tutorial will use a basic weather application. The aim is to learn how to create a Dockerfile - the primary requirement for containerizing an application.

More complex applications will necessitate multiple Dockerfiles, which will introduce Docker Compose and an orchestration tool like Kubernetes. However, these are beyond the scope of this tutorial.

The weather application, named Zeus, is a frontend application utilizing HTML, CSS, and JavaScript to showcase the weather forecast for a specified location.

To containerize an application, you need to create a Dockerfile. A Dockerfile is a text file that contains instructions for building a Docker image.

This Docker image can then be used to create a Docker container which is a running instance of the image.

Figure 1. Workflow for containerizing an application by MrDevSecOps on Medium

The steps below will guide you through the process of creating a Dockerfile for the weather application.

Step 1: Clone Weather App

To get the source code for the weather application, you can clone the repository from GitHub:



git clone https://github.com/Aahil13/Zeus.git

Step 2: Create the Dockerfile

Navigate into the application directory and create a file named Dockerfile.

Before diving into writing the Dockerfile for this application, here's a template Dockerfile outlining its various components:



# Use a base image with Node.js pre-installed
FROM node:14

# Set the working directory inside the container
WORKDIR /app

# Copy package.json and package-lock.json (if exist) to the working directory
COPY package*.json ./

# Install Node.js dependencies
RUN npm install

# Copy the rest of the application code
COPY . .

# Expose the port your application listens on
EXPOSE 3000

# Command to run your application
CMD ["node", "app.js"]

Here's a breakdown of each layer of the Dockerfile:



# Use a base image
FROM <base_image>

FROM: This instruction specifies the base image to use for your Docker image. The base image provides the starting point for your container.
<base_image>: You replace this placeholder with the name of the base image you want to use. For example, if you're building a Node.js application, you would use node:14 as the base image.
The base image is typically an official image from Docker Hub. You can find a list of official images on the Docker Hub website.



# Set the working directory inside the container
WORKDIR /app

WORKDIR: This instruction sets the working directory for any subsequent instructions in the Dockerfile.
It's similar to the cd command in a shell. All paths will be relative to this directory unless explicitly specified otherwise.
/app: This is the path inside the container where your application files will be copied. You can choose any directory structure that makes sense for your application.



# Copy the application files into the container
COPY . .

COPY: This instruction copies files from the Docker host into the container. It takes two arguments: the source path (on the host) and the destination path (in the container).
.: This represents the current directory on the Docker host. It copies all files and directories from the current directory into the specified destination directory (/app in this case) inside the container.



# Install dependencies (if any)
RUN <dependency_installation_command>

RUN: This instruction allows you to execute commands inside the container during the image build process. It's typically used to install dependencies, configure the environment, or perform any necessary setup steps.
<dependency_installation_command>: You replace this placeholder with the actual command(s) needed to install dependencies for your application.
For example, if you're using a Node.js application with a package.json file, you might run npm install to install Node.js dependencies.



# Specify the command to run your application
CMD ["<command_to_start_your_application>"]

CMD: This instruction specifies the default command to run when the container starts. It's similar to running a command in a shell after the container is launched.
<command_to_start_your_application>: You replace this placeholder with the actual command needed to start your application.

For example, if you're running a Node.js application, you might specify node app.js to start your Node.js server.

For the weather application, you can use the following Dockerfile:



# Base image
FROM httpd:2.4-alpine

# Copy the application files into the container
COPY . /usr/local/apache2/htdocs/

# Expose port 80
EXPOSE 80

The Dockerfile for the weather application is very simple because it's a frontend application that doesn't require any dependencies or configuration.

The base image is httpd:2.4-alpine which is an Apache HTTP server image based on Alpine Linux.

The application files are copied into the /usr/local/apache2/htdocs/ directory inside the container. This is the default directory for serving files with Apache.

The EXPOSE instruction exposes port 80 which is the default port for HTTP traffic.

Step 3: Build the Docker Image

Once you have the Dockerfile, you can build the Docker image using the docker build command:



docker build -t zeus .

docker build: This command builds a Docker image from a Dockerfile.
-t zeus: This option tags the image with the name zeus.
.: This represents the current directory on the Docker host. It tells Docker to look for the Dockerfile in the current directory.

Step 4: Run the Docker Container

Once the image is built, you can run a container based on that image using the docker run command:



docker run -d -p 80:80 zeus:latest

docker run: This command runs a Docker container based on a Docker image.
-d: This option runs the container in detached mode. It means that the container will run in the background and you can continue to use the terminal.
-p 80:80: This option maps port 80 on the Docker host to port 80 on the container. It allows you to access the application running inside the container through port 80 on the Docker host.
zeus:latest: This is the name of the Docker image to use for the container. The latest tag is used to specify the latest version of the image.

Step 5: Access Your Application

You can now access your application through your web browser.

If you're running Docker on your local machine, you can access the application at http://localhost.

If you're running Docker on a remote server, you can access the application at http://<server_ip_address>.

With the weather application, you should see a page like this:

Figure 2. Screenshot of the weather application

There are several things you can do with your Docker container. You can stop, start, restart, or remove the container.

To stop the container, you can run:



docker stop zeus

Conclusion

In this tutorial, you learned how to write a Dockerfile to containerize a simple frontend weather application.

You can use these same steps to containerize any application. The only difference will be the Dockerfile.

This is a high-level overview of the process of containerizing an application. For more information, you can read the Docker Documentation.

Avoiding DevOps tool hell

Onyeanuna prince — Mon, 24 Jul 2023 16:57:33 +0000

Have you tried to look at the beginners' roadmap to learning DevOps? If you haven't, don't worry; here's an image below:

Figure 1. DevOps roadmap by Vrashabh Sontakke

The image above shows 30+ tools a beginner must learn to become a DevOps engineer. Well, that's a lot.

Youtube tutorials, articles, and various blogs don't make this any easier, as they keep dishing out some much information without considering the users. Most times, these tutors need to gain experience in what it's like, to use these tools daily, hence why they can bombard individuals with so much at a time.

In this article, I will break down this problem and highlight a system I found effective when learning DevOps. This approach will give beginners and DevOps engineers, in general, an excellent method for applying and choosing various tools for a particular project.

What is DevOps?

DevOps is an approach that helps software development and IT operations teams work better together. Before now, these teams worked independently of each other and would often face challenges in coordinating their efforts. DevOps brings them together to improve how they collaborate and communicate.

Although this is true, this isn't all there is to DevOps. It is a set of practices that aids the building/development of software. To achieve this, there must be a shift in mindset and a set of tools to automate various processes/tasks. To achieve this automation, a good understanding of certain tools is crucial. However, there are so many tools to learn.

With a simple Google search, you could see a ton of DevOps tools and need help figuring out where to start. Hence, it is crucial to have a system to pick up tools to learn or use for any project.

Measures to consider while choosing tools

There are specific measures to look out for before choosing any tool for a job. These measures serve as requirements to be met by a tool. The following are measures to consider before adopting a tool:

Cloud agnostic tools

These are tools that function independently of any platform. These tools work and adapt easily to multiple public and private cloud providers. These tools are compatible with any cloud infrastructure without facing any operational issues. That means when using a cloud provider such as AWS; it is advisable to use tools that integrate with other cloud providers such as GCP, Azure, etc. Examples of cloud-agnostic tools include Kubernetes, Terraform, Vault, etc.

Ease of use

Learning how to use new tools can be difficult, and this difficulty can only get worse when you have to acquire further information while learning this tool. For example, learning a CI/CD tool such as Jenkins requires learning Groovy, which has a Java syntax. I found this difficult, as I needed to gain more knowledge of Java to learn this tool effectively. Learning CI/CD and Groovy simultaneously wasn't fun, and I had to abandon it after a while.

For this problem, I had to carry out research and found out that Gitlab CI uses YAML. YAML is an easy-to-read data serialization language. In DevOps, you encounter YAML in multiple areas, whether in Docker when using docker-compose or Kubernetes while writing Kubernetes manifests files, so it was easy to adopt Gitlab CI because I already had a prerequisite knowledge.

The Hashicorp corporation has made a huge impact in providing valuable tools and platforms in the cloud ecosystem. The advantage of using the tools they provide, such as Terraform, Vault, and Packer, is that they all have the same language, Hashicorp Configuration Language (HCL). This means you can easily pick up any of these tools by learning HCL, which is similar to JSON. This approach can be useful when choosing tools to learn or use for a project.

Immutable infrastructure

In making well-informed decisions, such as whether configuration management tools are needed, you need to know the type of infrastructure you manage or run.

A mutable infrastructure is one where you can change or modify the infrastructure at any time. An immutable infrastructure, however, is one in which changes cannot be made while it is live, but rather, the existing infrastructure is destroyed and replaced with a new one.

With a mutable infrastructure, you can use configuration management tools such as Ansible, Chef, Puppet, etc for modification. However, since changes aren't made to immutable infrastructures, you can't use these tools. This is where a tool like Packer comes in handy.

Packer can help you bake a preconfigured machine AMI where your infrastructure gets installed and configured at boot time. You won't need configuration management.

Running an immutable infrastructure comes with advantages such as reduced infrastructure complexity which results when the application grows larger. Therefore, if you're running this type of infrastructure, you won't need any configuration management tools.

Environment-native services

A good understanding of cloud providers is an important skill in this profession. They offer an array of services that enable you to build, deploy and manage applications quickly and effectively. Cloud Providers have advanced over the years, offering basic if not all, the tools needed by a DevOps engineer.

Although it is good practice to use services independent of any cloud platform, it is advisable to start your infrastructure in the cloud. As the application grows and a need to add another cloud platform comes in, you can switch to a cloud-agnostic tool. Why use many other tools when you can use these services offered on one platform? This solution isn't limited to cloud providers alone, as it can be extended to CI/CD tools.

When collaborating in teams, version control systems are used to keep track of the versions of the application. Platforms such as Github and Gitlab stand out in this ecosystem, and they come with numerous features asides from version control and source control management. They come with their own CI/CD platforms.

Using the CI platform with GitHub and GitLab, which is GitHub Actions and Gitlab CI, is not just cool but a smart choice for DevOps engineers. It aids in seamless integration and familiarity and is easy to use. While most engineers would use Github to store their code, then use Jenkins to checkout the repository, why not use the tool that comes with Github instead? Adopting the services within a particular environment, be it a cloud provider, or a repository manager, reduces the complexity of your infrastructure.

With these checks, you can make sure you choose the most appropriate tool for the job.

Tool to learn

Using these checks before picking a tool is crucial in making the right decision; however, what tool do you learn? Don't get me wrong, you still have to learn a handful of tools, but don't worry, now that you have a good system, you'd know how to use a hammer instead of a drill for a nail job. Below is a list containing various DevOps tools and their respective areas of use:

Infrastructure management: To automate the process of setting up and managing cloud infrastructure, a tool like Terraform is king!
Containers and Container Orchestration: Packaging applications and their respective dependencies have never been easier using Docker while orchestrating container infrastructure with an effective tool such as Kubernetes.
Monitoring and Logging: Monitoring statistics and obtaining logs from applications can be done using tools such as Prometheus and Grafana.
Security: All forms of data can be lost without security in applications. Using a tool such as Vault from Hashicorp can be helpful.
CI/CD: As discussed earlier, GitLab CI and Github Actions can save time to learn as they are familiar and easy to use.
Server templating: Using Packer has never been easier to create reusable server configurations in a platform-independent and documented manner.

Note: Cloud providers provide the equivalent of each of these tools, and it is essential that you know at least one cloud provider and the respective equivalent of these tools to use the right tool at the right time.

Conclusion

This article highlighted the problem of having too many tools and needing a proper manner of adopting the right tool for a project. This is not a paid post or a promotion to any company. However, it is based on the personal opinion of an individual who found it difficult to start my DevOps journey and was crippled by the fact that I had too much to learn.

Don't let the conversation end. This article was drafted from a conversation between Aahil and Francis from the DevOps Learning Space (DLS). Don't be left out. What do you think? Do you agree with my opinion? I'd love to hear all about it.

Understanding Docker Architecture: A Beginner's Guide to How Docker Works

Onyeanuna prince — Thu, 08 Jun 2023 22:28:38 +0000

This article was originally posted on Everything DevOps.

Using Docker, developers can package all their code and its dependencies into an isolated environment called an image and then run that image as a container. With Docker, deploying an application from a development server to a production server without worrying about compatibility issues is easy.

Aside from knowing basic Docker commands, while learning Docker, it is necessary you understand how these commands work. Therefore, in this article, you will learn about the fundamental components that make up Docker and how they work.

What is a Docker container?

Containers are lightweight, standalone units containing all the code and libraries needed to run an application. Unlike a virtual machine, a Docker container runs directly on the host operating system. This means it shares the host operating system kernel with other containers.

Docker containers are designed to be moved around easily between different environments without changing the application or its dependencies.

What is a Docker engine?

The Docker engine is the core of the Docker platform. It manages containers, including their creation, running and shipping and the entire lifecycle. When you install Docker, the Docker engine gets installed as well. This engine is the primary client-server technology that manages containers using all Dockers services and components.

The 3 fundamental components of the Docker engine

The Docker engine consists of three (3) fundamental components, including the Docker daemon, Docker API and Docker client.

Docker daemon
Docker daemon is a fundamental Docker component. It is a background process that listens to requests from the Docker client and manages the creation and running of Docker containers. The Docker daemon can be considered as the engine that powers the Docker environment. This allows developers to run, build and manage containerized applications.

The Docker daemon pulls Docker images from registries and manages the resources needed to run Docker containers. Docker daemon functions include:

Image management: The Docker daemon manages images, including pulling and caching images for fast and efficient container creation.
Volume management: Persisting data in containers is possible due to the Docker daemon. It enables the creation and management of volumes, which ensures data is saved when containers are deleted.
Network management: The Docker daemon manages communication between containers and the outside world. It manages container network interfaces, ensuring they are isolated from each other and the host machine.
Container management: The Docker daemon manages the starting, stopping and deleting containers.

Docker API
The Docker API is a programmatic interface that communicates with the Docker daemon. With the Docker API, you can tell the Docker daemon to perform tasks like starting, stopping and deleting containers or downloading or uploading Docker images. Docker API makes networks and volumes possible and manages user permissions and access.

All Docker daemon tasks are possible due to the Docker API. Without the Docker API, communicating with the Docker daemon programmatically wouldn't be possible.

Docker client
This is the primary mode of communicating with the Docker daemon. The Docker client is a command line interface (CLI) developers use to interact with the Docker daemon from their computers. When a user uses a command such as a docker run, the Docker client sends this request to the Docker daemon.

With the Docker client, developers can manage Docker containers, images, networks, and volumes from the command line. Below are the key features of the Docker client:

Command line interface: The Docker client provides developers a command line interface to execute Docker commands.
Integration with development tools: With the Docker client, it is possible to manage Docker containers from popular development environments, including Visual Studio Code and IntelliJ IDEA.

Note: Although the Docker API and Docker client may seem similar, as they are tools you can use to interact with the Docker daemon, they differ in a few ways. The Docker client sends requests to the Docker daemon via a Unix socket or a network interface, while the Docker API exposes a RESTful HTTP interface over a network.

Docker workflow

The Docker client, Docker API and Docker daemon work together for a complete Docker workflow. A practical example would be creating a container to see all these parts in action.

To create a Docker container, you would follow the steps below:

Step 1
Using the Docker client, you can pull an image from a registry (such as Docker Hub) or build an image from a Dockerfile.

$ docker pull nginx:latest //This will pull the nginx image from Docker Hub
$ docker build -t <image_tag> . // When you run this in a directory with a Dockerfile, it builds and tags it.

Step 2
Once you have an image, create a container using the Docker client.

$ docker run --name mycontainer -d nginx:latest

The above command requests the Docker API to create a container. The Docker API communicates with the Docker daemon to create the container. The Docker daemon sets up a network interface that allows the container to communicate with other containers or the host system. It also sets up volumes that the container can use to persist data.

Step 3
You can interact with the container once it's running using the Docker client. You can use the following commands to do this.

$ docker exec -it mycontainer bash # Execute a command inside a running container
$ docker logs mycontainer # View the logs of a container
$ docker stop mycontainer # Stop a container
$ docker start mycontainer # Start a container

Step 4
You can also use the Docker client to stop or delete the container.

$ docker stop mycontainer # Stop a container
$ docker rm mycontainer # Start a container

The Docker client sends commands or requests to the Docker API, which communicates with the Docker daemon to create and manage containers and their resources.

Alternatives to Docker

Although Docker isn't the first platform developers use for containerization, it played a significant role in popularizing containerization with a simplified process for creating containers and a user-friendly interface.

However, there are alternatives to Docker, such as container runtimes such as containerd and CRI-O and tools for building images such as Buildah.

Containerd: This is an open-source container runtime to manage a container's lifecycle. Docker and Kubernetes can use Containerd by providing a high-level API for managing containers and a low-level runtime for container orchestration.
CRI-O: This is an open-source container runtime designed for use with Kubernetes. It is a lightweight and stable environment for containers. It also complies with the Kubernetes Container Runtime Interface (CRI), making it easy to integrate with Kubernetes.
Buildah: This lightweight, open-source command-line tool for building and managing container images. It is an efficient alternative to Docker. With Buildah, you can build images in various ways, including using a Dockerfile, a podmanfile or by running commands in a container. Buildah is a flexible, secure and powerful tool for building container images.

Conclusion

Containerization is rapidly becoming the new standard for application deployment, and Docker is leading the way in this area. With its robust and flexible architecture, Docker makes it easy to build, deploy, and manage containerized applications on any platform.

If you're looking to improve your application deployment process or if you want to explore the exciting world of containerization, it is advised that you dive in and explore Docker.

To learn more about Docker, check out the following resources:

Using Node.js for Ecommerce: Pros and Cons

Onyeanuna prince — Tue, 14 Mar 2023 18:00:55 +0000

Node.js is a JavaScript runtime environment which developers use to build scalable network applications. You can use it in various software, including ecommerce platforms.

To deliver high performance and speed for ecommerce applications, Node.js is one of the best choices. It provides features like an event-driven, non-blocking I/O model. It also provides an extensive ecosystem of third-party modules and packages. With Node.js, it is much easier to build applications.

This article highlights the pros and cons of using Node.js in ecommerce. It’ll guide developers to make informed decisions about whether to use Node.js for ecommerce solutions or not.

What is Node.js?

Node.js is an open source, cross-platform JavaScript runtime environment. It is built on a V8 engine and is known for its speed and performance. Node.js enables JavaScript development on the server side.

The traditional client-side JavaScript is executed within a web browser. However, Node.js runs JavaScript code outside of a web browser, allowing it to be used for server-side development.

Node.js has a non-blocking I/O model; it can handle multiple requests simultaneously without blocking the execution of other code. It differs from conventional server-side technologies, which typically operate on a threaded model where individual threads manage each request.

Node.js is a flexible tool used for building a vast number of projects, including the following:

Web servers: Using Node.js as a web server guarantees speed and flexibility.
Web applications: Node.js is a great choice for building real-time web applications. It is especially important for applications that require fast and scalable server-side logic.
Chatbots: Creating bots that interact and respond to users' requests is possible with Node.js.
Command-Line Tools: Node.js can help build command-line tools to automate repetitive tasks.

As seen in the image above, Node.js is the most popular web technology according to StackOverflow. It's a suitable choice for ecommerce as resources and relevant information to learn and use this language are readily available.

5 Pros of Using Node.js for Ecommerce

There are many advantages of using Node.js for ecommerce. This section outlines some of the advantages in detail.

1. Speed and Performance

Owing to the V8 engine it is built on, Node.js is known for its speed. The V8 engine compiles JavaScript code into machine code, allowing it to run faster than interpreted languages.

Additionally, Node.js can handle multiple concurrent requests due to its event-driven, non-blocking I/O model. Therefore, even under high-traffic conditions, Node.js can deliver quick response times, making it a viable choice for ecommerce applications.

2. Scalability

An advantage of web applications is the ability to automatically scale up or down depending on incoming traffic. This is true for ecommerce applications that deal with growing numbers of users and transactions. It is therefore essential to utilize Node.js in building ecommerce applications.

Node.js is scalable due to its single-threaded event-loop, non-blocking I/O model, and modular design. Adding more servers, distributing the workload among them, and increasing each server's resources allows the system to scale.

This means that you can add more resources to a single Node.js server to increase its capacity or you can add more servers to handle an increasing amount of traffic.

3. Large Community

Node.js has an extensive community of developers willing to provide support, resources, and tools. You can utilize these to build ecommerce applications. With a growing library of packages and modules, Node.js offers developers the resources to create efficient and reliable ecommerce applications.

It's easier to find solutions to problems and stay updated when information is more accessible and easy to learn.

The following are avenues to join various Node.js communities:

4. Modular Approach

Ecommerce applications handle large amounts of data, and managing this data becomes increasingly difficult over time. However, Node.js developers use a modular approach to develop these applications.

Node.js supports a modular approach to development that allows you to break down code into manageable and functional blocks. It makes building, maintaining, and testing code easier.

5. Integration with Other Technologies

Node.js is compatible with various technologies. You can integrate Node.js with technologies ranging from frontend frameworks to databases and other programming languages.

With this advantage, it becomes easier to build ecommerce applications that integrate with other systems and services critical to business. Some of these services may include payment services, third-party systems, etc.

Node.js offers some critical advantages for ecommerce applications. You can create robust, efficient, and scalable ecommerce applications that meet your business and customers' needs by leveraging Node.js's advantages.

3 Cons of Using Node.js for Ecommerce

While Node.js has a lot of pros for developing ecommerce applications, there are also some cons. When developing an application with Nodejs, developers should carefully consider the tradeoffs and prepare to address these cons. Some of them are outlined below.

1. Limited Library Support

As of 2022, the official repo for Node.js packages (NPM) contains over 1.5 million packages, indicating that there is an extensive library of packages available for Node.js. However, not all of these packages are relevant or suitable for ecommerce applications.

Some critical functionalities required for ecommerce applications may have limited support or only a few packages available. Inventory management, order processing, and payment gateway integration are essential for ecommerce applications but may have limited support in Node.js libraries.

Developers can write code from scratch to implement these features. However, it could take a long time and restrict the number of features included in the application. Therefore, it's important to carefully evaluate the availability and quality of packages when building an ecommerce application using Node.js.

2. Callback Hell

When there are deeply-nested callbacks inside a function, it's referred to as "Callback Hell". Node.js suffers from callback hell because it heavily relies on asynchronous programming. Callbacks are the primary way to handle asynchronous operations in Node.js.

Multiple asynchronous operations are nested inside one another. The code can become deeply nested and difficult to read and maintain leading to callback hell.

3. Single-Threaded Model

The Node.js single-threaded model means that all code runs on one thread making it efficient for handling I/O tasks. However, it can create issues with functions requiring significant processing power or I/O operations that can block other tasks.

Node.js runs on a single thread; hence any long-running operation can block this thread. This will prevent other requests from being processed. It can lead to slower response times and a degraded user experience.

In ecommerce applications, it is essential to have a scalable and responsive platform. This is important because it can handle a high volume of requests without causing performance issues.

5 Best Practices for Building an Ecommerce Platform with Node.js

The following are practical tips and recommendations for building scalable and secure ecommerce platforms using Node.js.

1. Choose a Reliable Node.js Ecommerce Engine

An ecommerce engine is a software solution that provides the core functionality for building an ecommerce application. It handles product catalogue management, order processing, payment processing, and customer management. It typically consists of APIs, data models, and user interfaces that developers can use to develop custom ecommerce applications.

Using a dependable ecommerce engine can help developers save time and energy in creating essential ecommerce features. It lets them concentrate on developing distinct capabilities and adaptations for their requirements.

One option to consider is Medusa. Medusa is a set of open source commerce building blocks that allows you to build bespoke commerce applications without using cumbersome commerce platforms. Medusa is built on Node.js and can be deployed on modern infrastructure like serverless or edge workers.

2. Consider a Modular Approach

Modules are supported by Node.js. It would be best if you used modules while building ecommerce applications. In addition, modules simplify the process of debugging code in development. If one module has an error, it won't break the entire code, as each module contains its functions.

Modular development allows developers to work on different application parts concurrently. It improves productivity and reduces development time. It also makes it easier to maintain and update the application since you can change individual modules without affecting the rest.

To implement a modular approach, developers can use techniques such as dependency injection and module bundlers like Webpack. They can also use pre-existing libraries and frameworks that support modular design, like Nest.js and Express.js.

To implement the modular architecture, follow the steps below:

Identify all the application's core features, e.g. user management, cart management, order management, etc.
Break down the modules into smaller independent modules where each performs a specific task. This will make it easier to test and debug.
Define clear interfaces between modules so that when you make changes to one module, they do not affect the other.
Utilize a package manager such as npm to manage modules and their dependencies.

3. Integrations

When building an ecommerce platform with Node.js, leveraging modern technologies for integrations is essential. This ensures seamless connections with other applications and services.

One way to achieve this is by using APIs (Application Programming Interfaces), which allow different systems to communicate with each other. APIs can help to integrate various services and features into the ecommerce platform. These platforms include payment gateways, shipping providers, customer relationship management (CRM) systems, and more.

Another approach is to use webhooks, which allow automatic notifications and updates to be sent from one system to another. For example, when placing an order on the ecommerce platform, a webhook can trigger an update to the shipping provider. This notifies them to fulfil the order.

Some examples of popular webhooks include:

Stripe: Payment and subscription events
Twilio: SMS and call events

By utilizing modern integration technologies, ecommerce platforms can provide a better experience for customers.

4. Frontend Development

The frontend of an ecommerce application is what the user interacts with directly. It includes the design, layout, and functionality of the website or web application. Utilizing modern frontend technologies can improve the user experience and increase customer engagement.

One popular modern technology for frontend development is the Jamstack architecture. Jamstack stands for JavaScript, APIs, and Markup. It is a modern web development approach that emphasizes pre-built markup, serverless functions, and client-side JavaScript. This approach helps to create fast and secure websites.

In addition to providing speed, security, and stability, Jamstack sites use static site generators. This loads quickly and are more secure than traditional server-side rendering methods. It is significant for ecommerce sites, where speed and security can impact sales and customer trust.

Jamstack technology enables third-party service integration, such as payment gateways or shipping providers, through webhooks and APIs.

Some other popular frontend technologies for ecommerce applications include:

React: A JavaScript library used to create user interfaces. It is well-known for its flexibility and ability to reuse components.
Angular: A framework for building web applications known for its robustness.
Vue.js: A progressive JavaScript framework for building user interfaces known for its simplicity and flexibility.
Next.js: A framework for building server-side rendered React applications, known for its performance and SEO benefits.

Today's ecommerce landscape requires optimizing websites for mobile devices, implementing responsive design, and utilizing the technologies mentioned earlier. It is because more and more users are shopping on their mobile devices.

5. Implement Security Measures

Implementing security measures on an ecommerce platform is crucial to protecting sensitive information. Such information includes customer data, payment information, etc. With proper security measures, your ecommerce platform can become protected from various security threats, such as hacking, phishing, and other cyberattacks.

By implementing proper security measures, you can help ensure that your ecommerce platform is secure and protected from these threats. It will help build trust with your customers and protect their sensitive information. This is crucial for the success of any ecommerce business.

Here are some best practices for enhancing security:

Secure the Server: Configure the server correctly, and make sure all security patches are current. Implement firewalls and intrusion detection/prevention systems to protect against unauthorized access.
Use HTTPS: The protocol encrypts data transmissions between the server and the client. It helps protect sensitive information such as login credentials and payment information.
Implement User Login and Permission Controls: This ensures that only authorized users can access the platform. It can include strong passwords and role-based access controls.
Cross-Site Scripting (XSS) and Injection: Implement measures to prevent these attacks, which could put customer data at risk. It can involve verifying input, using prepared statements, and encoding output.
Regularly Update Software and Plugins: Keep all software and plugins up to date with the latest security patches and updates.
Conduct Regular Security Audits and Testing: Regularly conduct security audits and tests to identify potential weaknesses and areas for improvement. It can include penetration testing, and code reviews.

By implementing these security measures, ecommerce platforms built with Node.js can better protect sensitive customer data and maintain customer trust.

Medusa and Node.js

Node.js offers a versatile and efficient platform for building fast, scalable, and secure ecommerce applications. Node.js has its downsides, such as limited library support, callback hell, and difficulty with concurrent processing. However, it remains a popular choice among developers. This is due to its speed, performance, and large community.

Medusa is already the leading commerce infrastructure for Node.js developers on GitHub. It provides a set of commerce modules built to make custom-development processes easier for developers. It provides core commerce functionality related to order and customer handling, product management, along with many other features such as multi-currency multi-channel support. You can read more about Medusa’s offering the Docs.

Deploying a Web Server with AWS: A Hands-On Approach

Onyeanuna prince — Thu, 02 Feb 2023 07:47:22 +0000

Build a reliable and safe web server using EC2 instances, Nginx, and a private network.

Introduction

Web servers play a very vital role in our technologically driven world. They make it possible for users to access websites over the internet. They are the backbone of the internet, as they act as a bridge connecting users with the content they are trying to access.

There is a rise in the use of cloud providers to deploy web servers. This increase in usage is not a surprise as they offer many advantages, such as scalability, flexibility, automation, security, and high availability.

Many cloud providers are available today, examples of which are Amazon Web Services (AWS), Google Cloud Platform (GCP), Azure, DigitalOcean, etc. This article will focus on using AWS to deploy the Nginx web server. We will also cover essential system admin practices such as using a configuration management tool - Ansible and setting up an Application Load Balancer (ALB) in AWS.

Prerequisites

This article aims at those with previous experience with AWS and a background in working with web servers. However, those individuals don't have to be experts in these, as this article will be a step-by-step guide to deploying a web server using AWS.

The technical know-how of the following tools is necessary to understand the content of this article:

An AWS account. To sign up, visit the AWS console.
Basic knowledge of Linux and its command line interface.
Basic understanding of networking concepts like IP addresses and subnets.

Project Overview

This article will guide you in deploying the Nginx web server on AWS. However, there is a slight twist to how we will achieve this. We will use the following tools to achieve the goal of this project:

Virtual private cloud (VPC). It will isolate our server from being accessed outside our network.
Two private EC2 instances. They will serve as our virtual machines.
Ansible. It will help us manage our EC2 instances.
An application load balancer (ALB). It will distribute traffic among our EC2 instances.

The EC2 instances will be launched in a VPC. We will then install and configure Nginx on these newly created instances using Ansible. Nginx has a default page, which we will update to display the hostnames of each EC2 instance. Distributing traffic between the two EC2 instances using the ALB allows us to see their hostnames.

Figure 1. The outcome of this project.

Figure 2. Architectural diagram of this project.

The following are the goals for this project:

Launch two private EC2 instances and define a logical network for them.
Deploy an Nginx server on each EC2 instance and then display the hostname of each EC2 instance on those servers.
Access the Nginx web server through the ALB domain name.

With that in mind, we will break down this project into three steps. Don't worry about confusing concepts; I will explain everything as we proceed.

Step 1: Launch the Instance

This step deals with setting up the instances on AWS, and the goals of this step include the following:

Set up a VPC.
Launch two private EC2 instances.
Connect to the instances via a bastion host.

Before we achieve our goals for this step, let us take a detour and take the definitions of the various services we are about to use.

Definitions

Virtual Private Cloud (VPC)

A VPC is a user-defined private network in the AWS cloud where you can launch resources accessible only within that network. It is isolated from other virtual networks in the AWS cloud.

The VPC is similar to our standard internet connection because it is assigned an IP address. It can connect to the internet through the internet gateway and has security just like our regular internet firewalls. The main difference is that the VPC can only be accessed when you are within its network.

Elastic Cloud Compute (EC2)

The EC2 instance is a virtual server available in the AWS cloud. It is a virtual machine that we can configure with various operating systems.

Think about having a virtual macOS or Linux machine without worrying about hardware. With these virtual machines, you can configure many settings as you wish, such as CPU, type of OS, memory, etc.

We can access the EC2 instances via SSH.

Bastion Host

A bastion host is an EC2 instance that has a specific purpose.

In a VPC, we use a bastion host to connect to our private EC2 instances. When you have private instances in a VPC, you cannot access these instances via SSH. The reason is that they do not have public IP addresses, so the bastion host must be created and placed in a public subnet.

A bastion host is also known as a jump server.

Now that we have these definitions out of the way, we can refocus on achieving the goals for this step. Let's begin with setting up our VPC.

We can use the following steps to set up a VPC in AWS:

Figure 3. AWS VPC console.

Click on the create VPC button in Figure 3 and follow the directions shown in the following images below.

Figure 4. Create VPC step 1.

Figure 5. Create VPC step 2.

Figure 6. Create VPC step 3.

Once you're done, you should ensure your connection looks like this before clicking on create VPC.

Figure 7. Confirm VPC configuration.

With that, we have completed our VPC. We move on to the next goal - creating private EC2 instances.

Use the following steps to set up an AWS private EC2 instance:

Navigate to the EC2 instance console and click on the launch instance button.

Figure 8. EC2 instance console.

The following steps are the configurations we will use in this project.

Figure 9. Set up EC2 instance step 1.

In figure 9, we set the names of our instances to demo and indicate that we are creating two instances with the same configurations.

Figure 10. Set up EC2 instance step 2.

We chose Ubuntu, which is a free-tier instance.

Figure 11. Set up EC2 instance step 3.

Select an existing key pair, or generate a brand-new key pair. It will automatically download to your PC once you create it.

If you want to make a new key pair, follow the steps below.

Figure 12. Set up EC2 instance step 4.

Figure 13. Set up EC2 instance step 5.

Configure the network settings to look exactly like the one above, choose the VPC we created earlier, and launch the instance. With this, we have created our private instance.

We can only connect to these instances once we have our bastion host, so let's do that now.

Navigate to the EC2 instance console again, click the launch instance button, and follow all the steps shown below.

Figure 14. Create Bastion host step 1.

Figure 15. Create Bastion host step 2.

If you followed the configurations shown in Figures 14 and 15, congratulations, you have created the bastion host. Let's navigate to the console to see our instances.

Your instance should look like figure 16.

Figure 16. Check EC2 instances.

To differentiate between the two EC2 instances we created earlier, we have to change the names, adding the numbers 1 and 2 to each of them, respectively. Hover over each instance to change the name, as seen in figure 16.

Now that we have our VPC, EC2 instances, and bastion host setup, let us connect to the bastion host via SSH.

We can use the following steps to connect to instances:

Open the command prompt. You can use the shortcut Windows + R and type cmd in the run dialog.

Figure 17. Open the command prompt.

Navigate to your downloads folder or where you stored the demo.pem SSH key we created earlier. We will use the code below to navigate to the downloads folder.

```
cd Downloads
```

Navigate to the AWS EC2 instance console, click on the bastion host instance, and click the connect button as shown in Figure 18 below

Figure 18. Connect to the bastion host.
Navigate to the SSH client tab and copy the example of connecting to the instance.

Figure 19. Copy the SSH example.

Paste the example SSH code into the command prompt. Make sure you are in the folder where you stored the demo.pem key.

Figure 20. Connect via SSH to the bastion host.

With that, press the enter key on your keyboard, answer yes to the prompt, and voila, you have connected to the bastion host.

Since the purpose of the bastion host is to act as a connecting bridge to the private EC2 instances, we will now have to connect to the EC2 instances.

The following steps will aid you in carrying out that task:

Copy the content of the demo.pem key, open a file with the same name in your virtual machine (bastion host), paste the content in that file, and save it.

```
#open the nano text editor
sudo nano demo.pem
```

In the AWS instance console, please navigate to the first instance, click the connect button, and copy the code to connect to it via SSH.

Figure 21. Copy the SSH example.

Paste the code into the bastion host; voila, you have connected to the demo1 EC2 instance. You can do the same for the second instance.

Figure 22. Connect to demo1 EC2 instance.

We are now done with step one of our project, and we hit all the goals we set for this step. Let's now move to step two, where the real fun starts.

Step 2: Install the Nginx Server

This step deals with installing the Nginx web server on our instances. The goals of this step include the following:

Setup Ansible.
Add the configuration files to install Nginx.

Before we achieve our desired goals for this step, let us retake a detour to talk about the service we are about to use: Ansible.

What Is Ansible?

Ansible is an infrastructure as code (IaC) tool that handles configuration management. It manages the resources on our remote servers (private EC2 instances). It automates all the configurations we want on our instances.

The configurations written in the ansible file are in YAML. We will set up ansible on our bastion host and create our configuration file, which we will use to install Nginx on our two EC2 instances.

The following procedure can be used to setup ansible on our bastion host:

Install ansible on your Bastion host instance. We will use the following lines of code to carry this out.

```
sudo apt update
sudo apt install ansible -y

#use the following command to check if ansible has been installed
ansible --version
```

Open the host file and add the IP addresses of the EC2 instances. Log on to AWS and get the IP addresses of the private instances.

```
#open the hosts' file
sudo nano /etc/hosts

#add the IP addresses
[demo1 IPaddress] altschoolServer1
[demo2 IPaddress] altschoolServer2
```

Navigate to your .ansible file and set up the host inventory file - this file is used to hold the IP addresses or host names of the remote servers (EC2 instances).

```
cd ~/.ansible

[server1]
altschoolServer1

[server2]
altschoolServer2
```

We will generate an SSH key from our bastion host to allow ansible to connect to our private instances.

```
cd ~/.ssh
ssh-keygen
```

Figure 23. Generate SSH key.

Navigate to the location of the newly generated key, and copy the key we just generated.

```
cat ~/.ssh/id_rsa.pub
```

SSH into the private instance, navigate to the authorized_keys files inside the .ssh folder, and paste the newly generated key.

```
cat >> ~/.ssh/authorized_keys
```

Let's create a roles folder in the .ansible directory. This folder will contain modules of our configuration, allowing us to have a very neat playbook (more about this later). The roles folder will have this structure.

```
/roles
   nginx
     main
       tasks    
         main.yml
    php
      main
        tasks    
          main.yml
```

Create a folder structure like the one above and add the following lines of code to the first main.yml file.

```
#module to install and configure nginx
---
- name: Update package manager's package list
  apt:
    update_cache: yes

- name: ensure Nginx is at the latest version
  apt: name=nginx state=latest

- name: start Nginx
  service:
    name: nginx
    state: started

- name: Setup Nginx conf
  template:
    src=nginx.conf.tpl
    dest=/etc/nginx/nginx.conf

- name: restart Nginx
  service:
    name=nginx
    state=restarted
```

This playbook will ensure that Nginx is installed on our remote servers. From our configuration above, we need the nginx.conf file. We will install Nginx on our bastion host and get this configuration file.

Once we get the file, we will copy its content and replace a similar file on the remote server.

Install Nginx on the bastion host

```
sudo apt install nginx -y
```

Navigate to the `nginx.conf` file and copy its content.

```bash
sudo nano /etc/nginx/nginx.conf
```

Make a file and name it nginx.tpl. Paste the content we just copied into this newly created file. With this configuration, we can now install Nginx.

We will use PHP as the language to display the hostnames of our instances. We will create another role similar to the Nginx role we just made. This one will be called PHP. Add the configuration below to the second main.yml file.

```
#module to install and configure php
---
- name: Install PHP
  apt:
    name: php
    state: present

- name: Install PHP8.1-FPM
  apt:
    name: php8.1-fpm
    state: present
    update_cache: yes

- name: Start and enable PHP8.1-FPM
  service:
    name: php8.1-fpm
    state: started
    enabled: yes

- name: Configure Nginx to use PHP 8.1
  copy:
    src: sites-enabled
    dest: /etc/nginx/sites-enabled/default

- name: Copy php file from control machine to remote host
  copy:
    src: index.php
    dest: /var/www/html/index.php

- name: restart nginx
  service:
    name=nginx
    state=restarted
```

From this configuration above, we need files that will replace their equivalents on the remote servers.

The first file we will need is the sites-enabled file. This file will change the configuration of Nginx to allow PHP files to run on the server. Copy the configuration below.

```
##
# You should look at the following URL's in order to grasp a solid understanding
# of Nginx configuration files in order to fully unleash the power of Nginx.
# https://www.nginx.com/resources/wiki/start/
# https://www.nginx.com/resources/wiki/start/topics/tutorials/config_pitfalls/
# https://wiki.debian.org/Nginx/DirectoryStructure
#
# In most cases, administrators will remove this file from sites-enabled/ and
# leave it as reference inside of sites-available where it will continue to be
# updated by the nginx packaging team.
#
# This file will automatically load configuration files provided by other
# applications, such as Drupal or Wordpress. These applications will be made
# available underneath a path with that package name, such as /drupal8.
#
# Please see /usr/share/doc/nginx-doc/examples/ for more detailed examples.
##

# Default server configuration
#
server {
        listen 80 default_server;
        listen [::]:80 default_server;

        # SSL configuration
        #
        # listen 443 ssl default_server;
        # listen [::]:443 ssl default_server;
        #
        # Note: You should disable gzip for SSL traffic.
        # See: https://bugs.debian.org/773332
        #
        # Read up on ssl_ciphers to ensure a secure configuration.
        # See: https://bugs.debian.org/765782
        #
        # Self signed certs generated by the ssl-cert package
        # Don't use them in a production server!
        #
        # include snippets/snakeoil.conf;
                # include snippets/snakeoil.conf;

        root /var/www/html;

        # Add index.php to the list if you are using PHP
        index index.php;

        server_name _;

        location / {
                # First attempt to serve request as file, then
                # as directory, then fall back to displaying a 404.
                try_files $uri $uri/ =404;
        }

        # pass PHP scripts to FastCGI server
        #
        location ~ \.php$ {
               include snippets/fastcgi-php.conf;
        #
        #       # With php-fpm (or other unix sockets):
               fastcgi_pass unix:/run/php/php8.1-fpm.sock;
        #       # With php-cgi (or other tcp sockets):
        #       fastcgi_pass 127.0.0.1:9000;
        }

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        location ~ /\.ht {
               deny all;
        }
}


# Virtual Host configuration for example.com
#
# You can move that to a different file under sites-available/ and symlink that
# to sites-enabled/ to enable it.
#
#server {
#       listen 80;
#       listen [::]:80;
#
#       server_name example.com;
#
#       root /var/www/example.com;
#       index index.html;
#
#       location / {
#               try_files $uri $uri/ =404;
#       }
#}
```

Create a file called site-enabled and paste the configuration into that file. Let's move on to the second file called index.php. This file will hold our PHP code which will display the hostname of our instances.

```
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Nginx Server</title>
  </head>
  <style>
    * {
      margin: 0;
      padding: 0;
      box-sizing: border-box;
    }

    body,
    html {
      height: 100%;
    }

    body {
      color: white;
      font-family: "Courier New", Courier, monospace;
    }

    main {
      height: 100%;
      background: url("https://i.ibb.co/pRC65CX/markus-spiske-iar-af-B0-QQw-unsplash.jpg");
      opacity: 0.8;
      display: flex;
      align-items: center;
    }

    h1 {
      font-size: clamp(4rem, 100vw, 2rem);
      margin-bottom: 1rem;
    }

    .container {
      padding-left: 2rem;
    }
  </style>
  <body>
    <main>
      <div class="container">
        <h1 class="heading-text">
          <?php
            echo "Hi, I'm a Server<br>"; ?>
        </h1>
        <h2>
          <?php
          $hostname = gethostname();
          echo "My name is: $hostname";
         ?></h2>
        <h3>ADD YOUR NAME</h3>
      </div>
    </main>
  </body>
</html>
```

With this, we have completely set up all our roles. Let's now set up our ansible playbook.

Our ansible playbook is the file that will hold all our roles. It contains the general configurations that will be applied to all the roles. Let's now create our playbook called demo.yml.

```
---
- hosts: all
  become: true
  roles:
    - nginx
    - php
```

To make all our configurations come to life, we must execute them. To run our configurations, we use the following command:

```bash
ansible-playbook -i host-inventory demo.yml
```

Our playbook should execute looking like figure 24

Figure 24. Execution of the Ansible playbook.

Installing and configuring Nginx automatically using Ansible is a beautiful feeling, some consider it art. But don't tell that to the sysadmin who has to debug it when something goes wrong!

We have installed and configured Nginx; let us move to step three. It is the final step of the project in which we will create our ALB.

Step 3: Setup the Application Load Balancer(ALB)

This step deals with setting up an ALB, and the goals of this step include the following:

Set up a target group.
Set up the ALB.

Let's proceed to understand what an ALB is.

What Is an Application Load Balancer?

An application load balancer (ALB) distributes traffic between multiple EC2 instances. It acts as a single URL that will display the content in both instances, increasing the availability of your application.

The first thing we will do in this step is to create a target group. It is what tells the ALB where to direct traffic. Let's begin now.

Navigate to the EC2 console, and locate the target group section.

Figure 25. Target group console.

Adhering to configurations as shown below, set up the target group.

Figure 26. Configure target group step 1.

Figure 27. Configure target group step 2.

Figure 28. Configure target group step 3.

Figure 29. Configure target group step 4.

With this, you should have a target group named demo-tg. Confirm that your target group is like figure 30.

Figure 30. Confirm target group.

We have our target group now; let us create a load balancer associated with that target group.

The following configurations can be used to set up an ALB.

Navigate to the load balancer menu and click the create load balancer button.

Figure 31. Create a load balancer.

Choose the application load balancer option.

Figure 32. Configure load balancer step 1.

Adhering to the configurations shown below, we will create our ALB.

Figure 33. Configure load balancer step 2.

Figure 34. Configure load balancer step 3.

Figure 35. Configure load balancer step 4.

From figure 35, we will open another tab to create a new security group for our ALB.

Figure 36. Create an ALB security group.

Figure 37. Set the inbound rules for the ALB security group.

Figure 38. Configure load balancer step 5.

Figure 39. Configure load balancer step 6.

With this, we have created our load balancer. The last thing we have to do is configure the security group of our EC2 instances.

The following steps are used to configure our EC2 instances security group:

Please navigate to the security groups menu and select the security group for our instances.

Figure 40. Configure security group step 1.

Edit the inbound rules to allow HTTP traffic from the load balancer's security group.

Figure 41. Configure security group step 2.

We will now confirm the health of our instances. To do this, use the following steps:

Navigate to the target group console and click on your created target group. Scroll down, and you will see a table similar to figure 42

Figure 42. The health of your instances.

Note: If your instances are unhealthy, you will have to wait for a few minutes, and if nothing changes, you will have to restart the Nginx service.

Voila, we are done! To see our live project, navigate to the load balancer console, copy the URL, and paste it into your browser.

Figure 43. Load balancer URL.

You should see our completed project as seen in the following images below:

Figure 44. Server 1.

Figure 45. Server 2.

To see the changes refresh the page and take note of the changes in the IP addresses.

We have successfully installed the Nginx web server on private instances using ansible and an ALB.

For cost management, It is advisable to use AWS's free tier services, as displayed in this tutorial. However, we will incur some charges if this project is left running for some time. Therefore, you will have to quickly shut down all the services we created during this project.

Conclusion

In conclusion, deploying a web server on AWS can be challenging for those new to cloud engineering. However, it is easy to deploy and manage a web server by following a hands-on approach and utilizing the various tools and services provided by AWS.

One of the most significant advantages of using AWS is the availability of free-tier resources. It allows users to test and experiment with the platform without incurring additional costs. Additionally, a wealth of information is available online for those who wish to dive deeper into the topics discussed in this article, such as Ansible and AWS.

With further research, you can unlock AWS's full potential and take your cloud engineering skills to the next level. It's all just a few clicks away - so why not take the plunge and see where the cloud can take you? Thank you for reading!

Traverse the Linux CLI - Debian distribution

Onyeanuna prince — Thu, 12 Jan 2023 20:41:38 +0000

A guide to traversing the command line interface of the Linux operating system using the Debian distribution.

Introduction

The command line interface (CLI) is a powerful tool available on every operating system (OS). It offers a wide range of possibilities ranging from creating folders and files, editing files, and carrying out operations as the root user of a computer. Other advantages include resolving basic networking and troubleshooting issues and greater control over the operating system.

Today, the Linux operating system has a wide range of applications. Servers, smartphones (Android), and networking devices such as routers all use the Linux OS. Therefore, using the Linux CLI to interact with the Linux OS is vital.

Debian is a distribution of the Linux OS. It is one of the oldest and most widely used distributions and is known for its stability and security. It is the foundation for other popular distributions such as Ubuntu and Raspbian. It is a widely used choice for web servers and cloud environments.

With the vast capabilities of the Linux OS, it is critical to understand how to manipulate its CLI for effective interaction. This article will explore the Linux command line and the essential commands to use its interface.

Prerequisites

This article is suitable for anyone looking to learn about the Linux CLI, regardless of their experience level. Its beginner-friendly approach makes it accessible to all readers. Even advanced developers can benefit from reviewing the article to refresh their memory on specific concepts. It is beneficial for beginners transitioning to the Linux OS.

Before beginning this article, you must understand the following concepts and tools:

Operating systems and how they work.
Experience using a terminal emulator or command prompt, such as the Windows Command Prompt or macOS Terminal. (Windows command prompt would be used as a reference in this article).
A working installation of a Debian distribution, either on a physical machine or in a virtual environment.

What is the command line?

As the name implies, the command line is an interface that allows you to type in commands. It is a text-based interface where you input a command, the command gets interpreted, and then it is executed by the kernel.

The command line uses the keyboard, not the mouse, unlike the graphical user interface. It has a blinking cursor called a prompt, ready to receive your commands. Once a command is typed into the prompt, the enter key is pressed, and the command gets interpreted.

The command line can be accessed using a terminal in macOS/Linux or the command prompt in Windows. The terminal/command prompt is an application that allows you to interact with the OS through commands from the command line.

In the Windows OS, you can get to the terminal by pressing the Windows key and the letter "R" on your keyboard to open the Run dialog. Then, type the cmd command and press enter.

We have discussed a general overview of the command line. Now let's see what the Linux CLI looks like.

The Linux command line interface

In Linux, a shell interprets commands. The shell is a command line interpreter that reads and executes your commands. There are several shells in Linux. The following is a list containing the various shells available on the Linux OS:

Bourne Again Shell (bash).
C Shell (csh).
The Korn Shell (ksh).
The Z Shell (zsh).

Note: Bash is the default shell in the Debian distribution, as with many other distributions of Linux.

To access the terminal in Linux, you use the shortcut Ctrl+Alt+T.

Before navigating the Linux command line, you must understand how Linux organizes and arranges files. We will discuss this next.

The Linux file system

The file system is the way an operating system arranges or stores files. Linux uses a hierarchical file structure, with the root directory (/) at the top. Below is a representation of the Linux file system.

Figure 1. The Linux file system.

To see the file system on your Linux machine, you must navigate to the root directory and list all the files. To do this, follow the steps stated below:

Open your terminal, and type the command cd /. This command changes the directory to the root directory.
Type the ls command to see a list of all directories.

Figure 2. Debian Linux distribution file system.

Figure 2, shows all the directories in the Debian Linux OS. Every directory contains files and sub-directories that perform specific functions.

Note: The root directory as seen in figure 2 differs from the root directory (/) at the top of the Linux file system. The root directory is the home directory of the root user.

The Linux prompt

The prompt in the CLI is the blinking cursor where you type commands. In Windows, the prompt contains the (C:) hard disk partition where the OS resides on the PC, the forward-slash (\) representing the root user, and the current working directory.

Figure 3. Windows command line

From figure 3, the C: drive is where the OS currently resides, the forward slash indicates that it is the root user and the "user\com" is the current working directory.

In Linux, the prompt varies. The prompt displays the current user, hostname, and current working directory.

Figure 4. Linux command line.

From figure 4, the current user is "onyeanuna." The hostname is Kali, and the current working directory is the root directory (/).

The dollar sign ($) in the prompt indicates that the user doesn't have administrative/root access (also known as superuser). If the user had a hashtag symbol (#), it would imply that they can execute programs as the admin/root user.

Note: To grant the current user administrative/root access, we use the sudo su command. To exit, use the exit command. You can observe these changes by taking note of the dollar sign ($) or the hashtag symbol (#) in the prompt.

With our knowledge of how powerful the CLI is and what the terminal, file system, and command prompt are, we want to know how to find our way around the Linux CLI. Let's dive into understanding commands essential for navigating the command line.

Basic Linux commands

Everything done in the CLI is carried out using commands. There are over a hundred (100+) commands in Linux, and knowing them and their respective options and arguments can be difficult.

Some commands help you understand other commands' purpose, usage, and functionality.

Before we begin, let's see Linux's general syntax for input commands.

#The syntax for using any command in Linux
command [argument] [options]

Linux commands come with arguments and options, which provide extended use cases for that command.

Present working directory command

The present working directory, pwd, is one of the most basic commands in the Linux CLI. The command line is a text-based interface; therefore, there is a constant need to know exactly where you are. The pwd command is the exact command that provides you with that information.

Knowing exactly where you are is essential as soon as you open your terminal, as it will determine how you traverse the command line. The pwd command outputs the path of your current working directory. The syntax to use this command is also straightforward.

pwd

The output of this command can be seen below;

Figure 5. Present working directory command in Linux.

The output, as seen in figure 5, is the current path to my working directory.

When you have ascertained your current working directory, you will now decide if you want to remain or move to your desired directory. The change directory command is used to execute this function. Let's talk about it next.

Change directory command

As the name implies, the change directory command cd is used to change the current directory. When you enter the terminal, you will want to move from one directory to another. This command makes such movements possible.

This command is not new for those coming from the Windows OS, and the syntax for using the cd command is as follows;

cd [file path]

You can move to any directory with the correct file path. Let's take an example.

Let's move to the /etc/init.d directory. This directory stores scripts used to start, stop or restart system services in Linux.

We would do this using the command below.

cd /etc/init.d

Figure 6. Change directory command.

You can notice the change in the prompt from figure 6 above. Interpreting the new prompt would mean we are inside the init.d directory, which resides in the etc directory. These files are located in the root directory indicated by the slash (/).

Note: You can also move one step above that directory using .. instead of a file path.

We are currently in the /etc/init.d directory, but we cannot see the files or directories it contains. To see these files, we will use the list command. Let's learn about it now.

The list command

The list command, ls, is used to list all the directories/files within a particular directory. When navigating the command line, you would want to know the files in your current working directory, and this command is made for that exact purpose.

Let's now view the files under the /etc/init.d directory. We can do this by using the following syntax;

ls /etc/init.d

Figure 7. The list command.

We can view the content of any file in two (2) methods. We can first navigate to the directory and then list all its files. Alternatively, from our current working directory, we can use the ls command with the exact path of our desired file.

The example above illustrates how to list files using the first method, let's now take another example using the second method. We will list the files inside the /dev directory from the /etc/init.d directory.

Figure 8. Application of the list command used from another directory.

From figure 8, we see that from the /etc.init.d directory; we can list the contents of the /dev directory.

Several options and arguments can be attached to the ls command for extended functionalities. The command that correctly defines all these arguments and options and their respective uses is called the man command. Let's talk about that next.

The manual command

The man command stands for manual; as the name implies, it is a manual for commands. The man command can be seen as a textbook that defines a command. This manual (textbook) outlines all the arguments and options as they apply to a particular command.

We will now use the man to see the arguments and options associated with the ls command. The syntax for this action is as follows:

man ls

Figure 9. The manual command.

Figure 9 shows that the manual pages provide you with the command name, synopsis, and description of the command. In this case, it provides options that can be used with the ls command.

Let us take an example. Let's execute the ls command with the -a option, which lists all files, including hidden files. To do this, we use the following syntax.

ls -a

Figure 10. Execution of the list command with the -a option.

Figure 10 shows the difference between using ls alone and attaching the option -a with the command. The second output displayed in figure 10 contains two (2) additional contents which are the. and .. directory.

We can also explore and apply all the other options on the man pages. All options have been adequately explained, making their use relatively easy.

Note: Due to the length of the manual, you may need to move to other pages to view the remaining content. To achieve this, you can use the arrow left ⬅ and right ➡ buttons on your keyboard to move to the previous and next pages, respectively. You can also use the arrow up ⬆ and down ⬇ keys to view other options slowly.

You can exit the manual by pressing your keyboard's 'Q' key.

The manual is very long and can sometimes be overwhelming. There is another command that functions similarly to the man command, but the only difference is that this command provides a summarised version of the man command. Let's dive into the help command.

The help command

The help command works similarly to the man command but it gives a brief description of any command, unlike the man command. Let us see the output of executing the --help command with the ls command.

The syntax to use this command is as follows:

ls --help

Figure 11. The help command.

Figure 11 shows the output of executing the --help command with ls. The output is shorter than the manual and straight to the point. Accurate descriptions of the options are given here too.

The main difference between the manual and the help command is that the manual can be used as a textbook for the in-depth study of a particular command while help can be used as a reference.

Advanced Linux concepts

Some other concepts are more advanced than the ones we discussed earlier, and they can be beneficial when navigating the Linux CLI.

Piping

This is a technique where the output of a command is passed in as the input of another command. You can put the output of command A (source) as the input of command B (destination).

This can be very efficient as it allows you to write multiple commands into a single-line command, passing data from a command from left to right.

Piping is done using the vertical bar "|" key, also known as the pipe. Let's take an example:

ls -al /etc | grep cron

Interpreting the command above, we are saying the following:

Give a long listing of all the subdirectories in the /etc directory.
Filter the list to only those subdirectories with the keyword "cron" in them.

Figure 12. Application of the piping technique.

From figure 12 above, instead of returning the long list of subdirectories in the /etc directory, we have a small list of subdirectories containing the "cron" keyword.

To appreciate how useful the piping technique is, let's execute the same command, but this time, without the pipe.

ls -al /etc

Figure 13. Listing files without the piping technique.

Figure 13 shows how lengthy the output of running our command would have been without the piping technique. This list goes on...

Figure 14. Visual representation of the piping technique.

Note: The grep command used in the example above finds and searches for strings in a text file. That is why it is commonly used with the " | "symbol.

Redirection

The redirection technique is similar to the piping technique. Just as the name implies, it redirects the output of a command into a different location in the file system. You can simply put command A will be executed, and its output will be stored in your desired location.

Redirection is done using the greater than keys, > and >>. With each having the following functionality:

The > symbol replaces the content of the desired location with the output of the executed command
The >> symbol appends the output of the command to the content already present in the desired location.

Let's take an example. We will create a file, add some text to it, then redirect some commands into the file using the > and >> commands.

nano example.txt

The nano command is used to open a text editor. We will now add the following text to the text editor.

This is an example file for testing the redirection command.

Press "ctrl + O" to save and "ctrl + X" to exit nano. We will now test the > command

ls -al > example.txt

From the command above, we are returning a long list and redirecting the output to the example.txt file.

To view the content of our file, we will use the cat command.

cat example.txt

Figure 15. Application of the redirection technique using >.

Figure 15 shows that our previous text has been replaced with our ls -al command. This is the effect of the > command. It replaces everything in the selected location. Next, we will look at the >> command.

ls | grep linux >> example.txt

From our command, we get a list of the current directory from which we would filter every subdirectory that contains the string "Linux" and direct this output to the example.txt file.

Figure 16. Application of the redirection technique using >>.

From figure 16, we can observe that, unlike the > command, the content of the desired location doesn't get replaced, but the output of the ls | grep Linux command gets appended to the end of the example.txt file.

Note: Piping and redirection are practical techniques often used when scripting and automating tasks.

Conclusion

In conclusion, Linux CLI provides robust and flexible functionality for interacting with Linux systems. No matter what level you are at or what experience level you have, learning to navigate and use the CLI can significantly enhance your productivity and ability to work with Linux systems.

Several reasons make the Debian distro an excellent choice for anyone learning and working with Linux, including its stability and security. Following the tips and techniques described in this article, you should now confidently use the Linux CLI on a Debian system.

In addition to what you already know about Linux CLI, there is much more that you can learn and discover. I encourage you to continue learning and exploring and to seek out additional resources if you need them. Once you gain familiarity with the Linux CLI, you'll be able to utilize it effectively.

Thank you for reading this article. I hope you learned something helpful.

Four Tips for Your DevRel Success.

Onyeanuna prince — Thu, 22 Dec 2022 13:12:12 +0000

Uncovering facts about the developer relations career path.

Introduction

Before the widespread adoption of the term "DevRel," developers often used various methods to connect with their peers and stay updated on new technologies. Some of these methods include attending conferences and meetups, reading online resources such as blog posts, and participating in online communities. DevRel teams now utilize these and other approaches to build and strengthen relationships between developers and the developer community.

Throughout this article, I'll share with you facts that will assist you in developing your career as a DevRel professional. You will be exposed to another perspective of DevRel that will positively affect how you relate to developers and how to maintain successful growth in this profession.

Let's begin.

DevRel Vs Dev Evangelism

Before we proceed to uncover these facts about DevRel, I would love to make a distinction between DevRel and developer evangelism. Both terms have been used interchangeably, but there are slight differences between them.

DevRel is a broad term that encompasses consistent efforts made by companies to maintain relationships between developers and the developer community. It bridges the gap between the company and the developer community, ensuring that the needs of developers are met. Some of the tasks involved in DevRel include speaking at conferences, writing articles or blog posts, etc.

Developer evangelism, on the other hand, is focused on promoting a specific technology or platform to developers. This involves educating developers about the benefits and capabilities of the technology and helping them to understand how it can be used in their work. Developer evangelists often act as advocates for their technology and may work to build developer communities around it.

While both DevRel and developer evangelism involve interacting with developers, the main difference is in their focus. DevRel professionals are focused on building and maintaining relationships with developers, while developer evangelists are focused on promoting a specific technology or platform.

Now that we have made a distinction between DevRel and developer evangelism, let's dive into the facts about the DevRel profession.

Common Facts About The DevRel Profession

Know Your Mode of Education

DevRel is made up of four key areas which can be summarized into an acronym, CAFE. It can be broken down into the following:

Community
Awareness
Feedback
Education

One of the most significant areas of DevRel is EDUCATION. It is the ability to teach developers about your software product, company, or new feature. It is an avenue where you pass relevant information to developers and there are a few modes through which you can achieve this.

Some of these modes of education include:

Writing
Speaking
Podcasts
Workshops
Video content

All these methods are used to implement the educational aspect of DevRel. It is therefore critical to understand which one works best for you. Knowing what mode of education works best for you is crucial, as it will help you produce very efficient content.

The primary goal of education is to impart knowledge and skills. The most effective way to do this is by ensuring that the message is being conveyed clearly and effectively to the audience, regardless of the mode used. To accomplish this, it is important to operate at the highest level of proficiency.

Master Your Mode Of Education

Conferences and meetups are means by which developers come together and interact with each other, share their experiences, and connect. During these events, various breakout sessions, workshops, etc take place, and these are opportunities for DevRel professionals to speak about their technology and a particular solution they have.

Before attending any of these events, you must master a particular method of education. Remember the modes of education we discussed earlier? It is important that you can interact with people through that mode before giving a presentation.

In any form of education, the objective is teaching. Therefore, being a master of one aspect would sharpen your ability to speak/teach at tech events.

Devs Lives Matter

Many times, our perspective of individuals before we meet them affects how we communicate or relate to them when we eventually meet them.

Imagine meeting your favorite sportsman or celebrity. Your mode of approach would most likely be transactional rather than relational. A transactional relationship is based on what each other can offer and benefit, rather than based on friendship. On the other hand, a relationship built on true connection and genuine friendship can be categorized as relational.

When I say a transaction relationship, I mean a type of relationship based on questions like this.

"Hey X, can you do this for me?"
"Hey X, my company has a meetup coming up. Could you speak at it?"

These conversations come up 90% of the time in a transactional relationship, which is a problem for DevRel. Remember it is called DEVELOPER RELATIONS for a reason. You must be intentional about forming a relationship with people and this can only happen once you can start caring about them and stop caring about who they are.

Let's bring it back to tech events. At tech conferences or meetups, when we encounter CEOs or individuals who have made a name for themselves, most times we do so out of the conventional "grow your network for business" mentality which would in turn lead our relationship to a transactional point of view rather than a relational point of view.

A tip for when you encounter individuals who are "BIG SHOTS" in your tech space would be to do the following:

Approach them from an "I want to know this person" point of view.
Your conversations with them should not revolve around what they can bring to your company.
Show concern and a keen interest in supporting them in any way you can.

Remember, most favors can be gotten simply through friendship alone, so strive to form a bond rather than a network.

Note: When I say I do not care about who they are, it is not to downplay their contributions to the tech space or community, absolutely not. I mean I wouldn't use that mindset in forming a relationship with them.

A relationship with them should be formed based on a genuine interest in getting to know them and not because of what they have accomplished in the industry.

Be Open-minded

Attending tech events can be a huge boost to your career in DevRel. You should be open-minded to attend any event at all regardless of if it was organized by your company or not, if you have to speak at the event or not, or if you have been given an invitation by the organization/community hosting the event.

Through events like this, without the pressure to grow your network, you tend to form genuine relationships. This is better than being compelled by your job to make bonds that lead to transactional relationships.

Conclusion

When educating a community, you should be concerned about whether the audience is learning. Show care for them. As a DevRel professional, your main target is the developer. Make bonds with them and show concern about their needs and challenges.

Companies benefit significantly from DevRel in the long run. It's just like angel investing. It could be risky, but it could also be very rewarding. It is not a one-off thing, as a relationship is not formed out of that, but out of genuine care. Follow these tips, and I can assure you that you will be able to build solid relationships that will positively impact your business. Thank you for reading!

Credits

A Beginner's Guide to Tailwind CSS

Onyeanuna prince — Fri, 26 Aug 2022 23:56:11 +0000

Understanding Tailwind CSS, its installation, and using its utility classes to create a simple grid section.

Introduction

When building a large project, you usually have multiple lines of HTML code, this results in an even lengthier style sheet. Most styles are going to be repetitive and this breaks the Don't Repeat Yourself (DRY) principle. Imagine you had classes that could help shorten your lines of CSS code and also make you develop faster. Won't that be amazing ?🤩 That's where Tailwind comes in.

It is possible to get these classes from Tailwind, so you don't have to write your custom styles. This article will introduce us to CSS frameworks and focus on Tailwind CSS, including how to install it and understand its key principles. We will use it to build a simple grid section to demonstrate how it works.

Take my hand 👫 as we embark on this amazing experience together. Buckle up, this is going to be an adventurous ride.

Prerequisites

Acquiring knowledge of a CSS framework requires that you already have a solid foundation of CSS (I mean, you can't use tailwind CSS effectively if you don't understand CSS 😅 ). Below are other requirements for this study;

Node.js installed on your PC. You can follow this link if you don't.
A big bright smile.😊

And that's it, we are ready for lift-off. 🚀

WHAT ARE CSS FRAMEWORKS?

CSS frameworks are predefined blocks of reusable code written in CSS syntax for styling a web page. We can say that they are CSS codes that have been written to be used by several places without rewriting the same code.

We can view a framework as a storage location that has prewritten code stored for future use. Let's say we want to style a button and the styles for that button would be used in several parts of our webpage. Instead of writing the code from scratch, we can go to the storage location (framework), select the code used for styling buttons, and use that code for our button.

There are several pieces of code for styling different parts of a webpage contained in frameworks e.g. navbars, cards, colors, etc. Therefore, using a framework in your project leads to faster completion. There are several CSS frameworks available, below is a list of the 5 most popular CSS frameworks in no particular order.

Tailwind CSS
Bootstrap
Materialize
Bulma
Foundation

In this article, we are interested in Tailwind CSS. Let's dive deep into it 🏊.

WHAT IS TAILWIND CSS?

This is a highly customizable, utility-first, beginner-friendly CSS framework, that enables developers to build beautiful designs without leaving their HTML page. Utility-first means that Tailwind classes carry out specific tasks and they are not predefined components that cannot be customized. That means, a class called flex in Tailwind simply means display: flex in plain CSS and nothing more.

Tailwind allows developers to build any design with the help of low-level classes. These classes are very easy to understand, as their naming conventions are very specific to their use, making them very beginner friendly. 😇

Tailwind classes are highly customizable. You can tweak the classes to your standards for your design. It is very flexible and very easy to make any change to your style. With its mobile-first approach, it makes building responsive sites relatively easy by eliminating the need for numerous media query breakpoints.

WHY TAILWIND CSS?

At this point, we know Tailwind is a great tool to use in our project regardless of size, but that's not all. Using Tailwind can give us a whole lot of other benefits. Below are 3 advantages of using Tailwind CSS.

(1) Speed of development

Using Tailwind's utility classes, we need not worry about naming conventions, and context switching between HTML and CSS files. They are relatively easy to customize as well, making the development process more efficient.

We can build large projects faster with the use of Tailwind as compared to using other frameworks and writing custom classes.

(2) Customization

In Tailwind, customization is very easy. You can easily override its default configuration with a tailwind.config.js file in your project. This file is gotten during the installation of Tailwind and customizing it is straightforward.

Everything ranging from screen sizes to colors and font family can be customized with ease using the Tailwind configuration file.

(3) Specific class names

One major struggle for beginners using CSS is naming classes. You are constantly thinking of what class name would be specific or generic. Using Tailwind eliminates this problem as the classes are very specific to their function. Most times you could guess the name of a class without looking at the tailwind documentation.

Using Tailwind reduces the number of times you have to create custom classes and this solves the problem of naming classes.

That's enough talk, 🤫 we know what Tailwind is, and why it is awesome, let's solidify our knowledge by installing Tailwind and using these utility classes, to create a simple grid section. Get ready, here comes the sweet stuff. 😁

INSTALLING TAILWIND CSS

There are 4 ways of installing Tailwind, but we'll use the Tailwind command line interface approach, this is the fastest way of getting Tailwind from scratch. Let's get into it.

Step 1

Install tailwind via node packet manager(npm) - a large registry for software packages. Open your command line, navigate to the location of your project and use the code below to install it.

NOTE:

Before using any npm package, we must initialize npm into our project, the result of doing this is a package.json file. We will use the command below to initialize npm;

npm init

You'll get a prompt asking for details of the project, like the author (which is you), a git repository, etc., we'll skip them and complete the prompt. With that, you are set to install Tailwind.

Let's use the command below to install Tailwind.

npm install -D tailwindcss

This command will download a node_modules folder, containing all the files for using Tailwind in your project, and also adds a package-lock.json file.

Step 2

Create your tailwind configuration file. We will use the command below for that.

npx tailwindcss init

The tailwind.config.js file is used to define all your customized styles. If nothing is specified in this file, you will be using the default styles as specified by Tailwind. You can customize a lot of styles here, some include colors, screen sizes, font family, etc.

At this point, your folder should look like this. 👇

Step 3

Configure our template paths. In the tailwind.config.js file, we have to configure all files that contain tailwind class names. Tailwind needs this information because it scans through those files to generate the corresponding styles for those utility classes.

This configuration happens in the contents section of your configuration file. Let's get into it.

Navigate to the configuration file.

Go to the contents section and add the paths to all your files that will contain utility classes. In my case, I will add the path to my HTML file, but you can also add the path to your JavaScript file.

This will scan through all the HTML files in my project and look for Tailwind utility classes.

Step 4

Create our main CSS file. Inside this file, we will add Tailwind directives, these directives offer special functionalities to our Tailwind project. They are special Tailwind at-rules(@) that we can use in our CSS. Examples of tailwind directives are @apply, @tailwind, and @layer, but more about each of them later.

We'll create a src folder, add our CSS file there and add the following Tailwind directives. See below;

@tailwind base;
@tailwind components;
@tailwind utilities;

Step 5

Start the build process. We have to compile the Tailwind file and have it constantly updated whenever we add new utility classes. In the build process, Tailwind scans the HTML file and any other static file paths we set in our configuration file to find utility classes, then generates the CSS styles for those classes.

Starting the build process requires a command and there are two ways of executing this command. We can either do it in the command line or add it to our package.json file. We'll use the package.json approach.

Navigate to the package.json file, inside the scripts section and add the code below;

"build": "tailwindcss -i src/input.css -o dist/output.css"

This command builds Tailwind from our main CSS file(input.css) and compiles it in the output CSS file(output.css). The output file is the CSS file we will attach to our HTML.

Add the watch command to the scripts section.

The watch command constantly updates the output file. It looks for any changes made and builds the CSS again. Immediately after the build command, you add the watch command.

"watch": "tailwindcss -i src/input.css -o dist/output.css --watch"

Run the command

We'll go to our command line and run the command npm run build which will build our styles for us.

It created a distribution folder dist for us, with an output.css file in it. The content of the output.css file is compiled styles from our input.css file. This is the file we'll link to our HTML because all styles will be compiled and stored in this file.

If we take a look at our command line result, it says that Tailwind didn't find any Utility classes. That is because we don't have any Utility classes in our HTML yet.

We are done with setting up Tailwind for our project, 💃😀 this is when we begin our grid section project. Let's go!! 🚀

A SIMPLE GRID SECTION PROJECT

There is no better way to learn than to use the newly acquired knowledge to practice. Over the next few sections, we will build a beautiful grid section to solidify the knowledge we have on Tailwind and explain some key elements necessary in its application.

This is the demo of what we'll be building.

Let's begin !!🚀

(1) Link the output.css file in your HTML

As earlier stated, the output.css file will be the main stylesheet for our project as all the utility classes will be compiled into it. We'll use the code below to link it to our HTML.

<link rel="stylesheet" href="./dist/output.css">

(2) Create grid skeleton

We'll create a div and add Tailwind's utility class of grid, this will make the display of the div to be a grid. See this below 👇

<div class="grid grid-cols-2 grid-rows-3">

</div>

The following Tailwind classes mean the following in plain CSS;

The grid class means {display: grid}

The grid-cols-2 means .grid-cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }

The grid-rows-3 means .grid-rows-3 { grid-template-rows: repeat(3, minmax(0, 1fr)); }

If we observe, we are building our grid section ourselves with the help of the utility classes. If we want to specify any change at all, there is a utility class for it, we just have to check the official Tailwind documentation.

Currently, we have to rebuild our files to see the changes made, but instead of running the npm run build command every time we make a change, we will use the npm run watch command. Remember, we added the watch section to our scripts in our package.json file during installation, all we have to do is run it. This will watch for any changes and build our CSS for us.

Go to your command line interface, and copy the command below to build our new changes. We'll notice that new changes have been added to our output.css file.

npm run watch

Take note, that every time a change is made, Tailwind will rebuild our CSS for us. See below👇

If we check our output file, we will see that Tailwind has scanned through the paths we specified, which is the HTML, converting all the utility classes to plain CSS and storing them there. We can confirm by scrolling to the bottom of the output CSS file. See below 👇.

Before we complete our grid, one useful resource that will assist us in building this project is the Tailwind extension. It will assist us in completing class names and on hover, it will show us the meaning of the utility class in plain CSS. It is available for those using vs code IDE for development. You can get it here.

(3) Let's add the content of our grid.

The main grid section contains 6 div with different colors. Let's add them now.

        <div></div>
        <div></div>
        <div></div>
        <div></div>
        <div></div>
        <div></div>

This is just the skeleton of the boxes, it does nothing yet, we will add the background colors and some generic styles to them. To do this, we will go to our configuration file, add the different color codes we will be using, and reference those colors in the HTML. To do this, follow the steps below;

Under the extends object in the config file, create another object called colors and add the colors in a key-value pattern.

extend: {
      colors: {
        SoftRed: "hsl(7, 99%, 70%)",
        Yellow: "hsl(51, 100%, 49%)",
        DarkCyan: "hsl(167, 40%, 24%)",
        DarkBlue: "hsl(198, 62%, 26%)",
        moderateCyan: "hsl(168, 34%, 41%)",
        White: "hsl(0, 0%, 100%)",
      }

See my code below;

Go to your HTML, and add a reference to the colors for each div.

        <div class="bg-White"></div>
        <div class="bg-Yellow"></div>
        <div class="bg-DarkCyan"></div>
        <div class="bg-DarkBlue"></div>
        <div class="bg-moderateCyan"></div>
        <div class="bg-SoftRed"></div>

To add colors in Tailwind, the prefix 'bg' which stands for background, is appended to each color. Currently, nothing is displayed on our webpage because we've not set any width or height for the boxes. Let's do that now.

w-full h-60

The classes above specify width and height respectively. We'll add this code to all the boxes and watch the magic.

Yes!, we just created our grid. The last feature to implement is adding the texts and images. This is a challenge for you to attempt, you can submit a link to your project in the comments section.

Our code is working very well but there is one small thing we have to refactor. Tailwind allows us to write utility classes in our HTML and this is very cool, but they can become very long, making our HTML look rowdy. This is an ugly situation, but there is a solution to this problem.

We can give our different elements custom class names and still apply Tailwind's utility classes to them. We can do this with the help of Tailwind directives and our input.css file. Let's get into it.

TAILWIND DIRECTIVES (@)

As defined earlier, directives are special at-rules that offer functionalities to our Tailwind project. The 3 types of directives in Tailwind are @apply, @tailwind, and @layer. Let's dive deep into their meanings.

The @apply directive

This directive is used when we want to use utility classes on custom classes. You define the class, then use @apply followed by the utility classes. We'll use this to refactor our code later.

The @layer directive

This directive is used to tell Tailwind, 'Hey, this custom class belongs to this particular ' bucket' '. By bucket, we mean either the base, component, or utilities. We'll see them in practice very soon.

The @tailwind directive

This directive adds Tailwinds base, component, or utilities styles into our CSS. That means, for the base layer, we will be adding Tailwinds base styles to our CSS. An example of a base style can be a heading(h1 - h6) etc.

We know what directives are, let's refactor our HTML, and take all our utility classes to our input.css file. Let's go!🚀

Add custom classes to our HTML

We are moving all the inline utility classes from HTML to our CSS file, this will require a custom class that will hold all the utility classes in the CSS file. Therefore, we will copy the inline style, add a custom class and go to our CSS and paste the utility classes into our CSS file. Let's do it now.

    <div class="main-grid">
      <div class="bg-White sub-grids"></div>
      <div class="bg-Yellow sub-grids"></div>
      <div class="bg-DarkCyan sub-grids"></div>
      <div class="bg-DarkBlue sub-grids"></div>
      <div class="bg-moderateCyan sub-grids"></div>
      <div class="bg-SoftRed sub-grids"></div>
    </div>

The new HTML document looks like this. We removed the utility classes for the grid container and gave it a class name of main-grid and the boxes we gave a class of sub-grids. We'll add the utility classes in the input.css file

@layer utilities {
  .main-grid {
    @apply grid grid-cols-2 grid-rows-3;
  }
  .sub-grids {
    @apply w-full h-60;
  }
}

This is what our CSS looks like. We simply told Tailwind 'Hey, add the main-grid and sub-grids classes into the utility layer then apply their respective utility classes'. We just set our custom classes to contain Tailwinds utility classes this is pretty amazing 🤩.

We can also try out the base layer and apply a style to our body tag.

@layer base {
  body {
    @apply m-4;
  }
}

Here, we set the margin of the body to 1rem. The goal of refactoring our HTML is that it should look very neat now. Check it out.

This grid section was extracted from one of my projects. You can get the complete version from my github.

Conclusion

In this article, I introduced you to the amazing world of CSS frameworks using Tailwind CSS as a case study. Using a framework as good as Tailwind will double your production speed regardless of the size of your project. The fundamentals of using this framework have been elaborated here, but there's still much more to it, which is why it is advisable to have the documentation close by when building, to refer to it for class names or any conflicting issues.

We know how to carry out Tailwind installation from scratch, what terms like directives and utility classes mean, and used our knowledge in designing a grid section. That is good progress, thank you so much for sticking to the end. It was very long, but I'm sure we had a good time. Thank you for trusting me with your time, enjoy your newly acquired skill. 😎🥂

Credits

JAW-DROPPING FUNDAMENTALS OF THE 'this' KEYWORD IN JAVASCRIPT.

Onyeanuna prince — Wed, 10 Aug 2022 01:13:24 +0000

Knowing the meaning, and practical applications of JavaScript's 'this' keyword.

JavaScript's this keyword is an incredibly powerful concept. It most times tends to cause confusion among beginners or developers who don't understand how to use it, as well as contribute to unwanted bugs in our code. In this article, we will investigate what the this keyword means, and three (3) magical methods which are essential for its application.

Prerequisite

Basic understanding of HTML and CSS.
Basic understanding of JavaScript and how it works behind the scenes.

What is the 'this' keyword?

The this keyword is a special variable created for every function's execution context.

Behind the scenes in JavaScript, every function gets an execution context during execution. Each execution context comprises the variable environment, the scope chain, and the this keyword.

You can think of the this keyword as a pronoun in English. Let's take an example, My name is Aahil, I love to write. The "I" in the sentence is referring to "Aahil". That is what the this keyword simply does, it refers to the function that is calling it.

The value of the created this keyword, points to the owner of the function in which it is being used. In other words, when a function is executed, it gets its own distinct this keyword, whose value is the function in which the this keyword is used.

Unlike other variables, the this keyword is not a STATIC variable. It gets its value depending on HOW the function is CALLED. Below are 3 ways by which functions are called in JavaScript 👇:

(1) As a Method 👇:

A function declared in an object is a method. The value of the this keyword when used in a method, points to the object on which the method is called.

Let's take a code example.

const sample1 = {
  name: "Aahil",
  dateOfBirth: 1996,
  calcAge() {
    console.log(`${this.name} is ${2022 - this.dateOfBirth} years old`);
  },
};

sample1.calcAge();

Let's break down the code sample. The following activities occurred above;

The object literal called sample1 was created. It contains 2 properties, name and dateOfBirth, and a method called calcAge().
The calcAge() method prints to the console of the browser a string composed of the name property and a calculated date of birth.
The sample1 object calls the calcAge() method.

Output 👇:

The value of the this keyword above is the object that calls the calcAge() method which is sample1. Therefore, this.name is the same as sample1.name which is the string 'Aahil'.

We can go ahead and confirm the value of the this keyword. See the example below 👇

const sample1 = {
  calcAge() {
    console.log(this);
  },
};

sample1.calcAge();

Output 👇:

As we can see above, the this keyword points to the object sample1.

(2) As a normal function call 👇:

When we create a function, it is expected that the function must be called before it runs. The value of the this keyword when used in a function returns as undefined when that function is called. This is true only for function expressions and function declarations but not arrow functions.

NOTE👉: This only applies when you're in strict mode, otherwise, the this keyword points to the global window object.

Let's see this in action.

"use strict";

const sample2 = function () {
  console.log(this);
};

sample2();

In the code snippet above, we explicitly set the script to execute in strict mode. We also have a simple function expression sample2() which prints the this keyword to the browser's console.

Output👇:

As earlier stated, the value of this here is returned as undefined in strict mode. Now let's see the effect of having the same code run in sloppy mode.

const sample2 = function () {
  console.log(this);
};

sample2();

Output👇:

The output is the global window object - this is an object available in the global scope.

NOTE👉:
Using strict mode is very essential because it prevents JavaScript from failing silently and we set strict mode by adding the string '' use strict '' at the beginning of the script file.

We cannot talk about using this in function expressions and function declarations without mentioning its effect when used in ARROW FUNCTION.

As an arrow function 👇:

The arrow function is a simplified alternative for creating functions in JavaScript. Arrow functions don't get their own this variable, however, it uses the this keyword of its parent scope which is referred to as the lexical this keyword.

Let's take a code example.

const sample3a = () => console.log(this);

sample3a()

In the example above, the arrow function is logging the this keyword to the browser's console.

Output👇:

The result of running the code above returns the global window object. Remember, the value of the this keyword when a function is called in sloppy mode is the global window object. This means, the arrow function doesn't have its own this keyword, but it points to the this keyword of the outer scope(parent scope).

We can observe the this variable of the outer scope by just logging this to the browser's console without it being inside any code block(or function).

console.log(this)

Output👇:

The this variable of the outer scope is the global window object and that is why the this variable of the arrow function above is pointing to the global window object. The image below gives a summary of this.

We can see the value of the this keyword when the arrow function is put into another code block, in this case, another function.

const sample3b = function () {
  const sample3bArrowFunction = () => {
    console.log(this);
  };

  sample3bArrowFunction()
};

sample3b();

Let's break down the code snippet;

A function sample3b() which holds an arrow function sample3bArrowFunction().
sample3bArrowFunction() simply logs to the console, the this variable.

Output👇:

The result of this example is undefined. This is because the sample3bArrowFunction() doesn't get its own this variable, it uses the this keyword of the outer scope, which in this case is the function expression sample3b().

Remember from our background study, we established that function expressions return the value of this as undefined. Therefore, the this keyword of sample3bArrowFunction() will be undefined as well.

NOTE👉: The arrow function is not a way of calling a function, but it is an important and special case that we have to put into consideration when studying this.

(3) As Event listeners 👇:

When using event listeners in JavaScript, we select the element we want to listen to, then call the addEventListener() method with 2 parameters. The first parameter is the event we are listening for and the second parameter is the function that gets triggered when that event is triggered.

The this keyword inside the function that gets called when that event is triggered, points to the element which triggers that event. This is because in the document object model (DOM) all elements are objects, therefore, it would seem like an object was calling the function just like a normal method would.

Let's discuss this further with an example.

const buttonEl = document.querySelector('.btn')
const handleClick = function(){
    console.log(this);
}
buttonEl.addEventListener('click', handleClick);

The following steps are carried out in the code snippet above;

(1) A variable buttonEl holds the button HTML element.

(2) A function handleClick() simply logs the this keyword to the browser's console.

(3) The buttonEL has an event listener attached to it, with 2 parameters. Which are;

The click event, which listens for when the button is clicked.
The handleClick() callback function, is called only when the button is clicked.

Output👇:

The this keyword points to the element calling the event, and in this case, the element calling the event is the button element. This is why the output of our code snippet is the button element.

NOTE 👉:
The value of the this keyword is only assigned when the function is CALLED.

We have established that the this keyword is not STATIC, which means it changes based on how a function is called. However, there are ways we can manually set the this keyword. How cool is that, let's get into it.

The following three(3) magical ✨ methods are used to manually set the this keyword;

(1) The Call() method 👇.

The Call() method allows a function/method defined in an object to be used by another object without rewriting that method. By using the call() method, you can write a function once and then use it on multiple objects.

We make use of the call() method when we call a function. The call() method accepts a list of arguments, where the first argument is an object, this will be the value of the this keyword, and the rest are arguments pertaining to the function.

let's take a practical example.

function sample5() {
  console.log(`${this.name} is ${this.age} old`);
}

const sample5Obj = {
  name: "prince",
  age: 24,
};

sample5.call(sample5Obj);

The following actions occurred above;

A function sample5() simply prints to the console a name and an age.
An object sample5Obj holds two(2) properties, name, and age.

All this is nothing new at this point, until we call the function sample5() using the call() method, and we pass the object sample5Obj as an argument.

Let's see the result of this example.

Output👇:

The output above takes the name and age variables from the sample5Obj. This implies that the value of the this keyword is pointing to sample5Obj. This happens because we used the call() method to set it explicitly.

Remember that calling the function without using the call() method would have returned the value of this as undefined. Using the call() method, we can assign the function sample5() to multiple objects, we can see that below by adding another object.

function sample5() {
  console.log(`${this.name} is ${this.age} years old`);
}

const sample5Obj1 = {
  name: "Prince",
  age: 24,
};

const sample5Obj2 = {
  name: "Aahil",
  age: 45,
};

sample5.call(sample5Obj1);
sample5.call(sample5Obj2);

Here, we added another object sample5Obj2 to show that the function can be used in multiple objects and the this keyword would change depending on what object we pass into the call() method.

Output👇:

The result of calling the function sample5() on both objects changes because we are changing the first argument of the call() method.

NOTE👇:

The syntax for using the call() method is;

function.call(object, arg1, arg2,....,argn);

Where;

The first argument defines what the this keyword will be
The other arguments arg1, arg2, and argn defines the arguments of the function.

(2) The apply() method👇.

The apply() method does the same thing as the call() method, the only difference is that you pass the arguments of the function as an array instead of passing them directly.

Let's take a code example.

function sample6(name, age) {
  console.log(this);
  console.log(
    `${name} is ${age} years old and the name of this object is ${this.objectName}`
  );
}

const sample6Obj = {
  objectName: "object1",
};


const args = ["aahil", 14];

sample6.apply(sample6Obj, args);

Let's break down the activities above;

(1) A function sample6() with parameters of name and age. sample6() logs to the browsers' console the this keyword and a template string.

(2) An object sample6Obj which contains a property objectName.

(3) An array args which holds 2 items.

(4) sample6() is called using apply(). This takes the sample6Obj as the first argument, signifying that the value of this would be sample6Obj1, and it takes the args array as the second argument.

Output👇:

Let's analyze our output now;

(1) The first output we have is the result of logging the this keyword to the browser's console. The output is the object sample6Obj which we set by using the apply() method.

(2) The second output is the template string made up of elements from the args array. Using apply allows us to pass our arguments into an array and pass the array as an argument when we call the function.

NOTE:👉 apply() is not really in use now and the same pattern it uses can be done using the call() method and the spread operator.

Let's see this below 👇.

sample6.call(sample6Obj, ...parameters);

The output of this code will give you the same result as earlier.

NOTE:👇

The syntax for using the apply() method is;

function.apply(object, [args]);

The first argument defines what the value of this would be and the other argument defines the array of arguments pertaining to the function.

(3) The bind() method 👇.

The bind() method is used to set the this keyword explicitly, just as the call() and apply() method. The only difference is that instead of calling the function immediately, it returns a new function with the this keyword bound to it.

When we use the bind() method, we can get a brand new function with the value of this being whatever object we set it to. That function can now be used in multiple places.

Example👇:

function sample7(name, age) {
  console.log(this);
  console.log(
    `${name} is ${age} years old and the name of this object is ${this.objectName}`
  );
}

const sample7Obj = {
  objectName: "object1",
};

const sample7Bind = sample7.bind(sample7Obj);

sample7Bind("aahil", 24);

We have the same syntax as before and the only difference is the function sample7Bind(). This function is created when the bind() method is used on the function sample7() to explicitly set its this keyword to the objectsample7Obj.

sample7Bind() is called with the arguments of the function with its this keyword pointing to the object sample7Obj.

Output👇:

The output is the same as when we used apply() or call(), the only difference here is that the bind method returns another function, and the apply() and call() methods just call the function directly.

NOTE 👉: ** A useful application of using bind() is **partial application. This is when some arguments of a function are passed into the bind method as default, then on calling the function, that argument would be skipped as it now serves as a default parameter of that function.

Conclusion

This is a very lengthy article, but I hope we achieved our goals for this article and we got a deeper understanding of how the this keyword dynamically changes based on how functions are called and how we can explicitly determine the value of the this keyword.

One key thing to note is that the this keyword is simply a variable and whenever you're not sure of what the this keyword is, you can** simply log in to the browser's console** to be on the safe side.

Thank you for reading 😊.