Forem: Otuekong Arthur

Running A Headless Raspberry Pi

Otuekong Arthur — Sun, 31 Dec 2023 19:53:00 +0000

Imagine having a Raspberry Pi, a tiny computer that fits in your palm, running smoothly without the need for a monitor, keyboard, or mouse. This is what we call running a headless Raspberry Pi: a setup where the Pi operates without a traditional display and input devices. It might sound a bit techy, but it's simpler than you think.
In this article, we'll walk through the basics of running your Raspberry Pi headlessly, unlocking its potential without the clutter of additional peripherals.

Aside

I recently got a Raspberry Pi from a friend and many things have been flooding my mind on what to use it for:

Perhaps If I add another Raspberry Pi I could run a Kubernetes Cluster
Practice my Linux skills
Use it for some home automation ideas in the future.

Even though I have Ubuntu Linux running on my Windows machine, I still need the feel of a standalone Linux machine and my tiny raspberry pi cuts it for me.
Anyway, let's get to it.
These are the list of things I will be working with:

Raspberry Pi 3 Model B
SD card
A private Wifi network
Raspberry Pi Imager
RealVNC viewer
Putty

Note:
I recommend you install the recommended software on your machine before we start.

Overview

In summary, we are going to perform 9 steps:

Insert Or connect our SD card to our computer
Format the SD card
Selecting the Device and operating system in the Raspberry Pi Imager
Configure settings for our Raspberry Pi Os
Download Raspberry PI OS to our SD card
Insert Our Sd card into the Raspberry PI
Connect the Raspberry Pi to a power source
Remotely SSH into the Raspberry PI over a Wi-Fi network
Use RealVNC viewer to Remotely access the Raspberry PI over a Wi-Fi network

About Raspberry PI

According to Wikipedia, Raspberry Pi is a series of small single-board computers (SBCs) developed in the United Kingdom by the Raspberry Pi Foundation in association with Broadcom.
In summary, they say that a Raspberry Pi is a small computer that has all the Storage and memory (RAM) on a single and small board.
As earlier stated, I will be using a Raspberry Pi 3 model B with 1 gigabyte of Random Access Memory(RAM) and 8 gigabytes SD card for storage
First connect your SD card to your computer, if your machine has an SD card slot like mine then you may just slide it in else you should get an SD card adapter.
Launch the Raspberry Pi Imager and you’ll get to see the below screen:

Next, you will get to choose your Raspberry Pi device, go ahead and choose your device

In my case, I selected Raspberry Pi 3 as my option. You can see that it has all the submodels under it.
Go ahead and choose the Operating system(OS)

Next, click on Choose Storage and select your SD card as the storage

You may now click on the Next button.

At the click of the Next button, you’ll be prompted with the OS Customisation menu as below:

Under the OS customization menu are 3 tabs

General
Services
Options

First, the General tab provides a way to set our hostname for the Raspberry Pi and set username and password. Under Configure wireless LAN, Add your Wifi network name and password. Also choose your country under Wireless LAN country, in my case, I selected NG which is the symbol for Nigeria.
Next, under Set locale settings, choose your timezone and keyboard layout.
Move to the services tab:

Under the services tab, enable SSH(Secure Shell). This is very important as it will allow us to communicate with this device over the Wifi network through the terminal. Also, choose password authentication.
Done with the services tab, move to the Options tab:

Just as the name suggests, The Options tab is optional, but for me, I need my machine to play sound when it is finished downloading the OS. I also need it to automatically eject the SD card when completed and also enable telemetry which provides OS downloads data to Raspberry.
When done, click on the Save button and you will be presented with the confirmation screen below:

Click Yes.

You’ll then be prompted to confirm if you want to do this:

Since you are sure of what you are doing, click Yes.

If everything goes well, you should see the below output:

If you are getting the “Please insert a disk into ..” error like the below output

This little SD formatter tool should fix the issue.

After some time, the download will start:

If you chose the Eject media option, your SD card will be automatically ejected when installation is completed. If you did not, you will have to eject it yourself manually.
Next, we will run the Raspberry OS on our Raspberry PI.

Getting Raspberry Pi Running

Insert the SD card card into your Raspberry PI and plug in the power cable.
After some seconds your Raspberry PI should be up and running.
We need to find a way to communicate with this device.
Remember we had a wifi network as one of the things you’ll need in this tutorial?
Get your Raspberry Pi and your machine on the same Wifi network you configured in Os customization for the Raspberry Pi.
After you have them both connected to the same network, under
This is the time that we bring in one Putty. Putty is an SSH client that will let us communicate with our Raspberry Pi on the Wifi network using its IP address.
Open your Wifi router menu and copy the IP address of the Raspberry Pi on the network. Open Putty and paste the IP address like so:

Click on open.

You will be prompted to enter your username and password. If the login is successful, you should see a screen similar to below

Hurray, we are in.
We can use our tiny computer from here(command line) or even take it further and get a graphical user interface(GUI) from it.
To achieve this we need Virtual Network Computing(VNC) software. VNC is a remote access technology that enables computers to access and take control of another computer.
In this tutorial, we will be using a type of VNC called RealVNC viewer.
RealVNC comes in 2 parts: RealVNC viewer that we have installed on our machine and RealVNC Server that talks to us from the computer we want to access.
We have to get into our tiny machine and enable the RealVNC Server.
In the Putty terminal run the command below:

sudo raspi-config

On running the above command, you’ll be shown the screen below

What is of particular interest to us is the Interface Options. Navigate to the Interface Options using the arrow down key and press enter when you are there.
This gets you to the screen below:

Use the down arrow key to scroll to VNC and hit enter

Use the left and right arrow keys to toggle between Yes and No. Toggle it to Yes and press the enter key.
It shows that the RealVNC server is enabled by showing the following output

Click on enter and use the right arrow key to navigate to finish. Then press enter.
RealVNC Server is now ready to talk to our machine.

Accessing Raspberry Pi through RealVNC viewer(Desktop)

Open RealVNC viewer, click on the file tab then “new connection”.
The below output is what you should see next.

Copy and paste the Raspberry Pi IP address to the “VNC Server” then click OK.
Right-click on the monitor icon and click connect
It will ask for your RealVNC username and password, supply it and

Click Ok

You may play around with it, ensure you shut it down before you unplug the power cable.

Accessing Raspberry Pi through RVNC viewer(Mobile)

It is also possible to remotely access the Raspberry Pi with your smartphone.
To achieve this, search and install RVNC viewer on Google Play Store for Android or App Store for iOS.

Click on the + button

Next, input your Raspberry Pi IP address and click Create.
You will be presented with the below screen

Click on “Connect”
Add your username and password and click “Continue”

Behold your Raspberry PI on mobile

Conclusion

Running a headless Raspberry Pi offers an efficient way to use this versatile mini-computer. By eliminating the need for monitor and input devices, you not only save space but also open up possibilities for various projects and applications.

Introduction to YAML for Kubernetes

Otuekong Arthur — Sat, 16 Dec 2023 21:47:52 +0000

Welcome as we go through the basics of YAML, the go-to configuration language for Kubernetes. No tech jargon or complex terms here, just straightforward insights to help you understand YAML.
In this article, we will check out YAML as it pertains to Kubernetes.

YAML?

YAML, short for YAML Ain’t Markup Language, is a file format for making configurations. It is a data serialization language for all programming languages, which means it acts as a middleman to let programming languages talk to each other. Although Kubernetes files can be written in JSON and XML, YAML is the most preferred for this.
Among the benefits of YAML are:

Human readable
Intuitive Structure
Easy to Learn and Write
Versatility in Configuration

Assumptions:

I assume that you:

Know what Kubernetes is
Know what Kubernetes config files are.

If you know the above, let's jump right into it.

Understanding YAML

It will be nice to get some understanding of YAML.
Let's start with indentation.

Indentation

YAML uses indentation to represent the structure of data. Think of it like an organized to-do list. Each task (or data element) is neatly indented to show its relationship to the broader category. Indentation signifies the hierarchy and relationship between different components in a YAML file.
Notice how in the first countries list, the countries are all aligned, while in the second countries list the fact that the countries are not all aligned makes it invalid YAML.
YAML takes indentation very seriously.

#valid yaml
countries:
  -Nigeria
  -India
  -USA
  -Germany

#invalid yaml
countries:
  -Nigeria
-India
  -USA
  -Germany

Key-Value Pairs

It uses a key-value pair structure. Let's look at how this key-value setup works.

name: Otuekong

In the above example, the colon separates the key from the value, with the name being the key and Otuekong being the value.

Sequence/Lists

Sequence/List offers a way to group related data in YAML.

countries:
  -Nigeria
  -India
  -USA
  -Germany

In the above example, the countries key has a list of strings representing different countries.

The above may also be written as:

countries: [Nigeria, India, USA, Germany]

There are nested lists too in YAML. See it as a list inside a list or lists inside a list.

nested_list:
  - list1
  - list2:
      -sublist1
      -sublist2

In the preceding example, the nested_list key has list1 and list2 under it.list2 holds sublist1 and sublist2

Scalars

A scalar is a single piece of information, such as a number or some text. It's like a basic building block for data, like a single Lego piece instead of the whole Lego set. Scalars in YAML are simple, just like writing a single number or a short sentence. They help you express simple stuff without getting too fancy or complicated.
There are 4 scalar types in YAML:

Strings
Numbers
Booleans
Null

Let’s go a little deeper into the scalar types.
Strings
Unlike Javascript-Object Notation(JSON), Yaml accepts strings with or without quotation marks.


name: Hector #string without quotation marks

name2: 'Hector' #string with quotation marks

The above demonstrates the two ways of declaring a string in YAML and they are both valid.

Numbers
When it comes to numbers, it can be represented in YAML as:

Integers
Floating-point numbers
Scientific notation (exponential notation)
Hexadecimal and octal notation (using 0x and 0o prefixes)
Numeric strings

age: 50 #I am an integer
temperature: 23.5 #I am a floating-point
large_number: 4.022e23 #I am a scientific notation
hex_value: 0xFF #I am a hex value
octal_value: 0o12 #I am an octal value
numeric_string: "007" #I am a numeric string

Booleans
In YAML, on, true, and yes represent true while off, false, and no represent false.

#These are all true values
christmas: on
harmattan: true 
holiday: yes 

#These are all falsy values
rains: off
travel: false
something: no

Null
Null represents the absence of a value. It can be represented with the string null or the tilde sign (~) which on most keyboards is located on the top-left corner of the keyboard, to the left of the number 1 key.

christmasHamper: null 
reason: ~

The above snippet demonstrates the usage of null.

Maps

A map is like a dictionary where you have a key (the word) and a value (the definition). Maps in YAML help organize data in a clear and easy-to-read way.
The snippet below represents a simple map under the key scores. Each entry within the scores map consists of a name (key) and a corresponding score (value).

scores:
  Williams: 45
  Francis: 13
  Charles: 65

Comments

Comments are like little notes you can add to explain things. You put a # (hash symbol) and then write whatever you want next to it. YAML ignores it as it's just for you and others to understand what's going on.

desserts:
  - Cupcakes #This is a comment
  - Chocolate Chip Cookies
  - Brownies

#This is also a comment

YAML in Kubernetes

It is possible to imperatively manage Kubernetes resources by directly giving Kubernetes the instructions to manage your resources but soon enough this will get tiring and complicated to manage. Then comes the declarative way. Using YAML configuration files. With this, you just write what you want Kubernetes to do in a YAML file, point Kubernetes to the file, and let it handle the rest. Let's relate what we learned up there to Kubernetes.
We will need a Kubernetes config file. For this, let's go with a Pod file:

apiVersion: v1
kind: Pod
metadata:
  name: merry_christmas
spec:
  containers:
  - name: nginx-container
    image: nginx:stable-alpine-slim
    ports:
    - containerPort: 80
  restartPolicy: Always
  nodeSelector:
    gpu: true
      activeDeadlineSeconds: null

Let’s break down the content of the above file.

apiVersion: This is a string scalar that Specifies the Kubernetes API version used.
kind: This is still another string scalar that Indicates the type of Kubernetes resource in this case Pod.
metadata: It is a map that Contains metadata about the Pod. In this case, It contains the name of the pod.
spec: This is a map that Describes the desired state of the Pod. This contains a map of:
containers: Specifies a list of containers within the Pod.
name: This is a string scalar inside containers stating the name of the container.
image: This is also a string scalar inside containers specifying the Docker image to use. 8.ports: This contains a list of ports for the container. 9.containerPort: This is a scalar integer and indicates to Kubernetes the port to open on the container in this case port 80.
restartPolicy: It is a string scalar that sets the restart policy for the Pod.
nodeSelector: This is a map that specifies node selection criteria for the Pod.
gpu: This is a boolean scalar indicating whether the node should have a graphics processing unit(GPU). Here it is set to true. It could also take yes.
activeDeadlineSeconds: Specifies the maximum time (in seconds) for the Pod to run. It's set to null scalar, indicating an undefined value.

Three things are worthy of note here. They are:

scalars represent single values which could be numbers, strings, booleans, and null.
Mappings represent key-value pairs.
Sequences represent lists of items.

Understand the above and throw in indentation and you are on your way to conquer YAML.

Conclusion

Understanding YAML is essential for anyone working with Kubernetes. In this article, we went into the basics of YAML, looking at indentation, scalars, maps, and sequences. We finally connected the dots and made sense of the pieces that make up YAML. I hope this article made YAML more approachable and in a way simplified your Kubernetes operations.
Thanks.

Resource

If you are looking to advance your understanding of YAML, I recommend this article.
YAML Tutorial: A Complete Language Guide with Examples

Getting Started With Kubectl: A Guide To Kubernetes

Otuekong Arthur — Tue, 12 Dec 2023 15:56:12 +0000

Kubernetes features and scalability make it a preferred choice for managing containerized applications. However, harnessing the full power of Kubernetes requires proficiency in various tools and one of the most essential among them is Kubectl.

In this guide, we will get into the heart of Kubernetes management, offering a guide to mastering Kubectl. This guide will equip you with the knowledge and skills needed to streamline your Kubernetes workflow. Let's navigate the complexities of Kubectl together and unlock the potential of seamless Kubernetes administration.

Prerequisites:

Before we begin, ensure you have the following:

Package manager, on macOS, you can use Homebrew, on Linux, you can use Snap, and on Windows, you can use a package manager like Chocolatey.
A Kubernetes Cluster: You need a working Kubernetes cluster. If you don't have one, you can set up a local cluster using tools like Minikube, Kind or use a cloud-based Kubernetes service like Google Kubernetes Engine (GKE) or Amazon EKS. In this article, I will be using Minikube.

Notes:
-Due to lengthy outputs, some screenshots may be cut off.
-If you are using Minikube,kubectl comes bundled with it.

I will be working from a folder I created on my desktop called kubectl_practice.

What is Kubectl?

Kubectl is a command-line utility designed for communication with Kubernetes clusters. It enables users to deploy and oversee applications, inspect and manage cluster resources, and examine logs.

Kubectl Installation

We will be looking at ways of installing Kubectl on Windows, Mac, and Linux.

On Windows, open Command Prompt or PowerShell as an administrator and run:

choco install kubernetes-cli

On MacOS If you have Homebrew installed, run the following:

brew install kubectl

On Linux For uniformity of installation,I will be using Snap, a package manager that comes bundled in most Linux distributions.
First check if you have Snap installed by running:
snap --version
You should get the output below if you have Snap installed.

If you don't have Snap installed, on Ubuntu-based systems you can do so by running
sudo apt-get install snapd -y
while on Red-hat-based distribution, you will first have to install the Epel repository with:
sudo dnf install epel-release -y
Then, update dnf with:
sudo dnf upgrade
Finally, install Snap with:
sudo dnf install snap -y

When you are done with the above steps, just run:
sudo snap install kubectl --classic
And you are in!

Verifying the Installation

After installation, verify that kubectl is working by running the command:

kubectl version

If you are using a cloud-based Kubernetes cluster, there are extra things you need to get Kubectl up and running.

Configuring Kubectl for cloud-based Kubernetes cluster

You need the cluster configuration details to connect kubectl to your cluster. These details typically include:

Cluster API Server: The endpoint where your cluster is running.
Cluster Certificate Authority: The certificate authority data for your cluster.
Authentication Token: A token for authenticating with the cluster (used in some configurations).

There are 2 ways of achieving this:

Using kubectl config command
Kubeconfig File

Using kubectl config command: To set cluster configuration using the kubectl config command, open a terminal and paste the following commands



kubectl config set-cluster my-cluster-name --server=https://cluster-api-server-address --certificate-authority=path/to/certificate-authority
kubectl config set-credentials my-cluster-cred --token=your-auth-token
kubectl config set-context my-cluster-context --cluster=my-cluster-name --user=my-cluster-

Replace my-cluster-name, https://cluster-api-server-address, path/to/certificate-authority, and your-auth-token with your specific cluster details.

Using kubeconfig file: You can directly edit the kubeconfig file (usually located at ~/.kube/config) to add multiple clusters. Manually add your cluster details in the clusters, users, and contexts sections.



apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: <certificate-authority-data>
    server: https://cluster-api-server-address
  name: my-cluster-name
contexts:
- context:
    cluster: my-cluster-name
    user: my-cluster-cred
  name: my-cluster-context
current-context: my-cluster-context
kind: Config
preferences: {}
users:
- name: my-cluster-cred
  user:
    token: your-auth-token

Once you've configured kubectl, you can test the connection by running:



kubectl cluster-info

Getting Minikube Ready

I will use Minikube to set up a Kubernetes cluster on my local machine.

For this guide, I will be using the bash terminal on Windows but command prompt or PowerShell will work fine. Let’s start a Minikube cluster of 3 nodes. Open the terminal and type:



minikube start --nodes 3

When Minikube is done starting, you will be presented with the below output

All good, we now have our Minikube cluster running.

Now let us get into business.

In this article, we will not be looking at all the commands that are available in Kubectl.To get you up and running, we will check out Kubectl commands as they pertain to:

Node and Cluster Management
Application Management
Updating and Deleting Application
Debugging Application

For a comprehensive list of all Kubectl commands please check the Kubectl documentation.

Below is a table of commands we will be looking at in this guide.

Commands	Uses
kubectl get	Retrieving information about Kubernetes resources
kubectl describe	Detailed information about a specific resource
kubectl logs	Accessing container logs
kubectl create	Creating resources
kubectl apply	Updating resources
kubectl delete	Removing resources from the cluster
kubectl exec	Running commands inside containers
kubectl cordon	Marks a node as unschedulable
kubectl uncordon	Unmarks a node as unschedulable
kubectl drain	Gracefully moves all pods off a node
kubectl set image deployment	Updating the container image in a specific deployment
kubectl api-versions	Lists the API groups and their versions understood by the Kubernetes API server.
kubectl api-resources	Display the available API resources

Node and Cluster Management

As a Kubernetes user, among the things you will be doing is working with nodes and clusters. This section will guide you on using kubectl to operate Kubernetes node and cluster.

Get Nodes

Do you still remember the cluster we created? Let’s now put it to use.

First, let’s get some information about the minikube cluster. In your terminal, type:

kubectl get nodes

This command gets information about the nodes in our minikube cluster and presents us with the below output:

Describe Nodes

Let’s go further and get detailed information about the nodes.

Type kubectl describe nodes and you will be presented with descriptions of all the nodes on your cluster.

Let’s narrow our command and get a description of our minikube control-plane node.

Type kubectl describe node minikube

Kubernetes returns an output stating details about the minikube node.

Before we move on, let's get information about our minikube-m02 node.

In the terminal, type: kubectl describe node minikube-m02

The above command displays a description of our minikube-m02 node below:

Cordon Nodes

Imagine you have a team of workers doing their tasks in an office. Now, let's say you need to do some maintenance on a particular desk and don't want anyone to start new tasks there until you're done. In Kubernetes, kubectl cordon is like putting a Do Not Disturb sign on that desk. It tells Kubernetes not to schedule any new work on a specific worker node so you can conduct maintenance on it.

Let us demonstrate this with our minikube-m02 node.

On the terminal,type kubectl cordon minikube-m02

Now our minikube-m02 node is restricted from having new pods scheduled on it.

Use kubectl describe node minikube-m02 to check if this is true.

Pay attention to the output,unshedulable now says true.

Get it to run new pods by executing kubectl uncordon minikube-m02

Drain Nodes

Next on our lineup is kubectl drain. If you ever need to remove all pods from a node, then kubectl drain is the man for the job.

It helps you prepare a node for maintenance by moving all the tasks and applications to other nodes. Let us see it in action.

In your terminal, type kubectl drain minikube-m03 --ignore-daemonsets --force

Before we press enter, let me explain what the above command does.

kubectl drain is the main command that tells Kubernetes to prepare a particular node for maintenance.
minikube-m03 is our particular node for maintenance.
--ignore-daemonsets : this tells Kubernetes not to move certain essential tasks called daemonsets to other nodes.
--force : the force flag tells Kubernetes not to wait for resources to terminate gracefully.

Now hit enter.

From the above output, we can see that the drain command does 2 things.

It cordons or stops the node from having new pods scheduled on it.
It then drains the node of existing pods.

Delete Nodes

With our minikube-m03 node drained, we are now ready to delete the node. Run this command

kubectl delete node minikube-m03

The screenshot below shows us that our minikube-m03 node has been deleted.

Cluster Management

It is advisable to regularly inspect the cluster API versions, as each new release of Kubernetes introduces new API versions and may eliminate older ones. To obtain a list of available APIs, execute the following command:

kubectl api-versions

The above output returns a list of API versions available that we can make use of.

Kubectl also provides a way to check the API resource list.

To get the available API resource list run kubectl api-resources

Our command returns the accessible resources, their short names, the API group to which a resource is affiliated, whether it is namespace-specific or not, and the specific KIND type.

Application Management

In this section, we will look at application management with Kubectl. Navigate to the kubectl_practice folder.

Let’s start with creating a deployment.

Create Deployment

In the kubectl_practice folder, create a file named practice-deployment.yaml with the provided content.



apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-container
        image: nginx:latest
        resources:
          limits:
            cpu: "0.5" 
            memory: "512Mi"  
          requests:
            cpu: "0.2"  
            memory: "256Mi"

Run kubectl apply -f practice-deployment.yaml to deploy using the configuration in the practice-deployment.yaml file.

The above command will present you with the console output below :

Let's check the status of our deployment by running kubectl get deployments

Create A Service

Services expose Pods to the network within or outside the cluster. Let’s check out how to create services with Kubectl .

I will create a file in kubectl_practice folder and name it practice-service.yaml with the below as the content of this file:



apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

Next, let's apply the configuration.

Type kubectl apply -f practice-service.yaml in your terminal and hit the enter key.

The screenshot below shows that our service was created.

You may check the status of the service by running kubectl get services which displays the output below

Nice, our service is running.

Create Pods

Creating pods directly in Kubernetes seems convenient but brings challenges in scalability, resilience, updates, and resource management. Using higher-level abstractions like Deployments and ReplicaSets ensures easier management, automatic healing, streamlined updates, and optimized resource use for a more efficient Kubernetes experience. For the above, avoid creating pods directly in Kubernetes but instead, use deployments.

In the kubectl_practice folder, create a file named practice-pod.yaml with the following content:



apiVersion: v1
kind: Pod
metadata:
  name: practice-pod-1
spec:
  containers:
  - name: my-container
    image: nginx:latest
    resources:
      limits:
        memory: "200Mi"
        cpu: "500m"   
      requests:
        memory: "120Mi"
        cpu: "250m"

---

apiVersion: v1
kind: Pod
metadata:
  name: practice-pod-2
spec:
  containers:
  - name: container-1
    image: nginx:latest
    resources:
      limits:
        memory: "150Mi"
        cpu: "300m"   
      requests:
        memory: "100Mi"
        cpu: "200m"

Now run this command kubectl apply -f practice-pod.yaml

If you follow everything correctly, the screenshot below should be the output on your terminal.

With our practice-pod.yaml file we created 2 pods. Let’s confirm this by running kubectl get pods

Get rid of these pods by running kubectl delete pods practice-pod-1 practice-pod-2

Updating And Deleting Application

Updating

There are many methods to deploy a new application version. Here, we will be focusing on two methods:

kubectl apply
kubectl set image

Open the practice-deployment.yaml file and change the docker image from nginx:latest to nginx:stable-perl.

Save the file and run the following command kubectl apply -f practice-deployment.yaml

Let’s run a quick command to get a description of our deployment.

In your terminal, type kubectl describe deployment my-deployment

In the above screenshot, did you notice that the container image changed from nginx:latest tag to nginx:stable-perl?

Let's use kubectl set image to change the container image tag to another version. Jump back into the terminal and type: ****

kubectl set image deployment my-deployment my-container=nginx:mainline

Get the description of our deployment by running kubectl describe deployment my-deployment

Exposing Application To The Internet

To make your application available on the internet, go into the practice-service.yaml file and change the type from clusterIP to LoadBalancer.

Apply the changes by running kubectl apply -f practice-service.yaml

Then run the get service command by typing kubectl get service

The below screenshot should be similar to the output on your console.

If you are using a cloud-based Kubernetes cluster, It might take minutes for your cloud provider to set you up. If you are using Minikube, you will need to start the Minikube tunnel to expose the External-IP.

On a separate terminal, run minikube tunnel

Then get back and run kubectl get service

By now the external IP status should change from pending to showing an external IP like so.

Copy the EXTERNAL-IP, and open it in a browser.

You have successfully exposed your application to the internet. Great job.

Deleting Application

Let us get information about our deployment and our service.

Run kubectl get service command to get our service.

Let’s delete my-service with kubectl delete service my-service

Try to get my-service with kubectl get service and you will notice it is no longer there.

Get the name of our deployment with kubectl get deployments and run kubectl delete deployment my-deployment.

Try to get our deployment with kubectl get deployments and you will get the below output:

Debugging Application

Sometimes things might not go as planned and you have to get into the pods to fix things. To demonstrate this, let’s create a fresh deployment.

In the kubectl_practice folder, create a file called myDatabase-deployment.yaml and paste the below content.



apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-database
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-sql
        image: mysql:oracle
        #env goes here
        resources:
          requests:
            cpu: "0.4"
            memory: "800Mi"
          limits:
            cpu: "0.8"
            memory: "900Mi"

Get into the terminal and type kubectl apply -f myDatabase-deployment.yaml

The above command gives the output below.

Try to get our deployment with kubectl get deployments and you will be presented with the output below.

For some reason,my-database deployment is not ready. Let’s get the pods in our deployment

Run kubectl get pods

From the above output, we can see that my-database— pod has the status of CrashLoopBackOff.What could this be?

Let's get a log of the pods, run kubectl logs my-database-7c44d9bcb4-h9h54

The preceding command shows a log of the pods. Line 3 of the logs is of concern to us where it displays that "Database is uninitialized and password option is not specified You need to specify one of the following as an environment variable:"
This means that we need to set a password for the database. To fix this, get into myDatabase-deployment.yaml file, under containers, add the below content:



env:
         - name: MYSQL_ROOT_PASSWORD
           value: secret-password

Next, get back to the terminal and run kubectl apply -f myDatabase-deployment.yaml
Confirm if our pod is running by executing kubectl get pods

Awesome our pods are running.
Finally, let's show how to use kubectl exec to run a terminal inside a container. I will be using Windows Powershell to demonstrate this.
If you are using Windows OS, open Powershell and navigate to our kubectl_practice folder.
First I will run kubectl get pods

Second I will get the pod name and exec into the container with
kubectl exec -it my-database-7c8c774899-jdqth -- /bin/bash

Let's get a list of directories/folders inside the container by running ls which stands for lists.

The above output shows the Linux directory structure inside our my-sql container.
Let's run mysql -p which will prompt for the password to be entered.

Remember we set the password to secret-password. Type it in and you will be presented with an output similar to this:

You may leave the container by running exit.

Conclusion

And there you have it, your journey into the world of Kubectl. We covered node and cluster management, application management, and updating and deleting applications, and even went as far as debugging your applications. Remember, mastering Kubectl takes practice but every command you learn brings you a step closer to becoming a Kubernetes master.
Keep this guide handy as you continue your Kubernetes exploration, and don't hesitate to experiment. The world of Kubernetes is dynamic and ever-expanding and Kubectl is your key to unlocking its full potential.

Containerizing your full-stack node app using Docker Compose

Otuekong Arthur — Sat, 04 Nov 2023 10:28:13 +0000

Containerization, particularly with Docker, has revolutionized the way we develop, test, and deploy software. Docker Compose, an essential companion to Docker, simplifies the process of managing multi-container applications. In this article, we embark on a journey into the world of containerization, focusing on containerizing a full-stack Node.js application using Docker Compose.

Whether you're a seasoned developer or just stepping into the world of containerization, this article will guide you through the process of Dockerizing a comprehensive application, from setting up your development environment to orchestrating multi-container setups effortlessly. By the end of this journey, you'll have a deep understanding of Docker Compose and the confidence to containerize your own full-stack Node.js applications, paving the way for efficient, scalable, and reliable software deployment. So, let's dive in and explore the transformative power of containerization in modern software development.

Prerequisite:

This article assumes that you have:

Docker Desktop
Node and Npm
Basic knowledge of react
Basic knowledge of tailwind css

To follow along, you will need the following already installed on your computer:

Docker Desktop
Node js
And a code editor

You will need tailwind CSS to get the styles I have used in this tutorial. Visit the Tailwind CSS documentation to get Tailwind up and running.

Let’s create a folder for our project.
Open the command line on Windows and terminal on Mac, navigate to your desktop or your desired directory, and create a folder with

mkdir Docker_Compose

Inside this folder

navigate inside the folder you just created with

cd Docker_Compose

inside the Docker_Compose folder, create two folders named frontend and backend with

mkdir frontend and mkdir backend

Getting our backend ready

navigate inside the backend folder with

cd backend

Initialize your express js backend package.json file with
npm init -y

The above command will create a package.json file in the root of your server and this file contains details about your project and its dependencies

Install Express.js using the following command.

npm install express

This will download and install the Express.js package for your project.

Before we get into creating our backend code, let’s create a script that starts up our server. In the root of our backend folder, open the package.json file and paste this command under scripts

"start": "node server.js",

Next, to avoid,cross-origin request issues from our backend, we’ll install cors npm package by running the following command

npm i cors

Open the Docker_Compose folder in your text editor and navigate to the backend folder you created.

Inside the backend folder, create a file called server.js, and paste the following code:



const express = require("express");
const cors = require('cors')
const app = express();
const port = 8000;

app.use(cors())

app.get("/", (req, res) => {
  res.json([
    {
      id: 1,
      joke: "Why don't scientists trust atoms? Because they make up everything!",
    },
    { id: 2, joke: "I'm on a seafood diet. I see food and I eat it" },
    { id: 3, joke: "I used to be a baker because I kneaded dough" },
    {
      id: 4,
      joke: "Why don’t some couples go to the gym? Because some relationships don’t work out!",
    },
    {
      id: 5,
      joke: "I'm reading a book on anti-gravity. It's impossible to put down!",
    },
    {
      id: 6,
      joke: "Parallel lines have so much in common. It’s a shame they’ll never meet",
    },
    {
      id: 7,
      joke: "Why did the scarecrow win an award? Because he was outstanding in his field!",
    },
    {
      id: 8,
      joke: "Why don't oysters donate to charity? Because they are shellfish!",
    },
    { id: 9, joke: "I'm on a whiskey diet. I've lost three days already" },
    { id: 10, joke: "I used to play piano by ear, but now I use my hands" },
  ]);
});

app.listen(port, () => console.log(`Listening on port ${port}`));

Start your Express server using the following command:

npm start

The above command will run your server on port 8000 on localhost, which you can access on http://localhost:8000 in your browser.

Getting our frontend ready

On our front end, we will be using Vite to initialize a React application.

Navigate to the frontend folder and input the following command

npm create vite@latest

After you are done initializing the react app, delete the content of the App.js file and paste the following code



import { useState, useEffect } from "react";

function App() {
  const [error, setError] = useState(false);
  const [jokes, setJokes] = useState([]);

  useEffect(() => {
    const fetchData = async () => {
      try {
        const response = await fetch("http://localhost:8000");
        if (response.ok) {
          const result = await response.json();
          setJokes(result);
          setError(true);
        } else {
          console.error("Error fetching data:", response.statusText);
        }
      } catch (error) {
        console.error("Error fetching data:", error);
      }
    };
    fetchData();
  }, []);

  return (
    <>
      <nav className='bg-red-50 py-4'>
        <p className='font-light text-4xl text-red-400  px-20 '>jokesVille</p>
      </nav>
      <main className='flex justify-center items-center px-6 py-10 bg-red-100'>
        {!error ? (
          <div
            className={`${
              error ? "flex" : "hidden"
            } h-full justify-center items-center text-center`}
          >
            <p className='text-xl font-medium'>
              So Sorry we could not find you jokes
              <span role='img' aria-label='dissapointed' className='text-4xl'>
                &#128542;
              </span>
            </p>
          </div>
        ) : (
          <div className='grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 justify-center items-center gap-x-4 gap-y-3 text-center my-10 py-5'>
            {jokes.map((joke) => (
              <div
                key={joke.id}
                className=' h-40 flex flex-col justify-center items-center bg-gray-50 rounded-md py-16 px-20'
              >
                <span role='img' aria-label='laugh'>
                  &#128514;
                </span>
                <p className='text-gray-500'>{joke.joke}</p>
              </div>
            ))}
          </div>
        )}
      </main>
    </>
  );
}

export default App;

Now fire up the jokesVille app frontend by running

npm run dev

There we have our app running nice and shiny in our browser

Frontend view in chrome

To reap the benefits of docker we will need to go beyond directly running our app on the browser but through docker containers.

Then comes Docker:

What is Docker?

Docker is an open-source platform that enables developers to automate the deployment of applications in lightweight, portable containers. These containers are a form of virtualization that packages an application and its dependencies together, creating a consistent and isolated environment for running software.

Why do we need docker?

1 Consistency Across Environments:

Developers often face the challenge of "it works on my machine" issues when deploying applications to different environments. Docker containers encapsulate applications and their dependencies, ensuring consistency across development, testing, and production environments. This consistency eliminates discrepancies between environments, leading to more reliable deployments.

2 Isolation and Resource Efficiency:

Docker containers offer both process and file system separation, enabling applications to operate autonomously from the host system. This separation guarantees that applications operate in their own space, preventing any interference and creating a stable, secure environment. Moreover, Docker's lightweight design demands fewer resources in comparison to conventional virtual machines, enhancing efficiency in terms of both memory and processing capabilities.

3 Microservices Architecture:

In contemporary software development, the microservices architecture is extensively utilized. Docker simplifies the creation and supervision of microservices by enabling each service to operate within its dedicated container. This method of development, which emphasizes modularity, improves scalability, fault tolerance, and simplifies maintenance.

What is Docker Compose?

Docker Compose is a utility designed to define and oversee complex Docker applications with multiple containers. It allows the comprehensive description of an application setup, encompassing services, networks, and storage allocations, within a unified docker-compose.yml file. This file serves as a plan for your application, outlining the construction, configuration, and interconnections of diverse containers.

To reap the above benefits, let’s get into running our app in Docker

To ensure our front-end displays in the browser when we run it in a container, go into vite.config file and replace the contents of the file with the following



import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";

export default defineConfig({
 base: "/",
 plugins: [react()],
 server: {
  port:3000,
  strictPort: true,
  host: true,
 },
});

You may choose to keep the default port: 5173, in my case I went with port: 3000. If you decide to go with a different port, do remember to change it accordingly in the frontend Dockerfile.

Containerizing our Application

To start, we have to create 2 docker files,1 in our frontend folder and 1 in our backend folder.
First, navigate into the frontend folder and create a file named Dockerfile, then paste the following command into the file:



FROM node:20.9.0-alpine3.18
WORKDIR /Docker_Compose/frontend
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "run", "dev"]

Before we move on to creating our backend docker file, let’s take some time to explain the content of the above docker file and what they do:

FROM node:20.9.0-alpine3.18

This line defines the foundational image for the Docker container. It begins with a minimal Alpine Linux system (version 3.18) and then adds Node.js version 20.9.0 onto this base system.

WORKDIR /Docker_Compose/frontend

This sets the working directory within the container to /Docker_Compose/frontend.

COPY packag.json ./

This line copies package.json from the host machine to the current working directory in the container (/Docker_Compose/frontend).

RUN npm install`

This command installs the Node.js dependencies specified in package.json

COPY . .

This command copies all files from the directory on the host machine where the Dockerfile is located to the active working directory within the container. This encompasses various items such as the application code and extra configuration files.

EXPOSE 3000

This informs Docker that the container will listen on port 3000 at runtime.

CMD ["npm","run","dev"]

This specifies the default command to run when the container starts.

To create our backend docker file, navigate to the backend folder, create a file named Dockerfile, and paste in the following commands

docker FROM node:20.9.0-alpine3.18 WORKDIR /Docker_Compose/backend COPY package.json . RUN npm install COPY . . EXPOSE 8000 CMD ["npm", "start"]

Next, navigate to the root folder (Docker_Compose) and create a file named docker-compose.yaml, then paste the following text

yaml version: "3.8" services: frontend: build: ./frontend container_name: jokesVille_client ports: - "3000:3000" backend: build: ./backend container_name: jokesVille_server ports: - "8000:8000"

In the root folder (Docker_Compose), and with Docker Desktop running, run the below command

docker-compose up --build

If you have been following the tutorial correctly, you should be greeted with a screen similar to this

Open http://localhost:8000/ and view the jokesville backend

Open http://localhost:3000/ on your browser and you’ll have our jokesville frontend nicely displayed and connected to the backend.

To shut down the docker containers, in the root folder run

docker-compose down

Conclusion

In this article, you've learned the process of containerizing your full-stack web application with Docker Compose. Initially, we set up a backend Express server with Node.js and developed a front-end application using React.js. Following these stages, Dockerfiles were generated for both applications, alongside a docker-compose.yaml file.
Using this docker-compose.yaml file, we built and launched the application containers.

Setting up environmental variables in React

Otuekong Arthur — Mon, 21 Aug 2023 19:43:55 +0000

Prerequisite:

This tutorial assumes that you have some knowledge of Html, CSS,Tailwind CSS,Javascript, and React.
At the end of this tutorial, you should be able to create and use environmental variables in React.

Overview:

what are environmental variables
Reason for environmental variables
Setting up and accessing environmental variables in create-react-app
Setting up and accessing environmental variables in Vite
Conclusion

What are environmental variables

Environmental variables in React are special variables that store configuration settings or sensitive information outside of your application's source code.
Environmental variables are typically stored in files named .env or .env.local at the root of your project.

Reasons for environmental variables

Environmental variables are useful for storing sensitive information like:

API keys
API endpoints
Database credentials

Setting up environmental variables in create-react-app

In React,environmental variables are declared by creating a .env file in your project root folder and declaring the variable name in all uppercase,like so
REACT_APP_YOUR_VARIABLE_NAME=thisismyFirstENVvariablewithCreateReactApp

Accessing environmental variables in create-react-app

process.env.REACT_APP_YOUR_VARIABLE_NAME

import "./App.css";
import { useState } from "react";

export default function App() {
  const [jokes, setJokes] = useState();

  const url = "https://jokes-by-api-ninjas.p.rapidapi.com/v1/jokes?";
  const options = {
    method: "GET",
    headers: {
      "X-RapidAPI-Key": process.env.REACT_APP_API_KEY,
      "X-RapidAPI-Host": "jokes-by-api-ninjas.p.rapidapi.com",
    },
  };

  async function getJokes() {
    try {
      const response = await fetch(url, options);
      const result = await response.text();
      setJokes(result);
    } catch (error) {
      console.error(error);
    }
  }

  return (
    <div className='App w-full flex justify-center items-center mt-40 '>
      <div className=' w-[80%] lg:w-1/3 bg-gray-500 rounded-lg py-6 space-y-6 shadow-xl '>
        <p className='text-white text-lg font-semibold px-3'>{jokes}</p>
        <button
          className='rounded-md bg-purple-400 text-white p-2 '
          onClick={() => getJokes()}
        >
          Get Advice
        </button>
      </div>
    </div>
  );
}

Setting up environmental variables in Vite React

Environmental variable in vite react starts with VITE_
like so
VITE_YOUR_VARIABLE_NAME=thisismyfirstENVvariableinVite

Accessing environmental variables in Vite React

import.meta.env.VITE_YOUR_VARIABLE_NAME

const options = {
    method: "GET",
    headers: {
      "X-RapidAPI-Key": import.meta.env.VITE_API_KEY,
      "X-RapidAPI-Host": "jokes-by-api-ninjas.p.rapidapi.com",
    },
  };

Conclusion

Environmental variables enhance security by keeping sensitive information, such as API keys or database passwords, out of source code. Storing these secrets as environmental variables helps protect them from accidental exposure and unauthorized access.