Kuberty.io
  • blog
Kuberty.io

Uncategorized

Home / Uncategorized
30Aug

How to Install Anaconda on CentOS 7

August 30, 2022 admin Uncategorized

Kubernetes (K8s) is a container orchestration system that helps manage containers at scale. Originally created by Google, Kubernetes is now an open-source system that is maintained by a community of dedicated developers. Kubeadm mechanizes the configuration of the Kubernetes elements. These include the API server, Kube DNS, and so on. Nonetheless, one cannot engage users or deal with the OS dependencies and their configuration.

That’s where configuration management tools like SaltStack and Ansible come in. Tools like these can help you create extra clusters or recreate existing clusters, making them effortless and more on point. This guide seeks to teach you how to install Kubernetes on CentOS 7 using Ansible and Kubeadm. Scroll down and read on.

Prerequisites to install Kubernetes on CentOS 7 

Before you go for the step-by-step process, there are some prerequisites that you need to take care of to install Kubernetes on CentOS 7. Yes, your Kubernetes cluster will comprise two resources that are as follows:

  • One master node

While talking about Kubernetes, we refer to each server as a node. The master node deals with managing the status of a cluster. It also helps run Etcd that stows cluster information among components responsible for scheduling workloads to worker servers/nodes.

  • Two worker nodes

The other resource is two worker nodes which are the running ground of your scheduled workloads (containerized apps and services). Once a workload is assigned, a worker server/node will keep on running, even if the master descends after scheduling the workload. Thus, we can make a cluster more capable by augmenting the number of workers.

Here are the prerequisites to install Kubernetes on CentOS 7:

  • An SSH key pair stored on your local computer.
  • A trio of servers having CentOS 7 along with 2 GB RAM and two virtual CPUs on each server. You should be capable of SSHing into each one of these servers as the root user by utilizing your SSH key pair.  
  • Ansible installed on your local Linux/macOS/BSD machine.
  • A basic understanding of Ansible playbooks.
  • Comprehension of the process of launching a container from a Docker image. 

Note: After you’ve gone through this entire article, you will learn how to make a cluster ready for running containerized apps. However, to do so, the cluster servers should have enough CPU and RAM resources consumable by your apps. You can containerize nearly any conventional Unix app, including daemons, command-line tools, etc., and run it on your cluster. The cluster itself will take about 300-500 megabytes of memory and 10% CPU on every node to function properly. 

Step-by-Step Guide to Install Kubernetes on CentOS 7

Here are all the steps that you can easily follow to install Kubernetes and start using it on your CentOS 7 system:

Step 1 – Set up the workspace directory and Ansible inventory file

The first thing to install Kubernetes on CentOS 7 is to set up your workspace directory and Ansible inventory file. To do so, you have to generate a host file that will contain inventory information. Here, you will find three servers, one among them being the master with an IP shown as master_ip. The others will be workers with the IPs worker_1_ip and worker_2_ip, respectively.

First, generate a new directory, namely ~/kube-cluster. Also, add a home directory to your PC and navigate into it by running the following commands in the terminal:

mkdir ~/kube-cluster

cd ~/kube-cluster

The directory you just created would remain your workspace for the entirety of the process. Also, it will have the whole of Ansible playbooks and be your go-to directory for running all the local commands.

Next, create a new file named ~/kube-cluster/hosts. For this purpose, you may utilize vi or any other text editor you like:

vi ~/kube-cluster/hosts

Now, press i for inserting the below text to this file for specifying info about your cluster’s logical structure:

~/kube-cluster/hosts

[masters]

master ansible_host=master_ip ansible_user=root 

[workers]

worker1 ansible_host=worker_1_ip ansible_user=root

worker2 ansible_host=worker_2_ip ansible_user=root

Once you’re done, press ESC and then follow it with :wq for writing the modifications to the file and finish.

As we mentioned before, Ansible’s inventory files are crucial for specifying server info like IP addresses, remote users, etc. It also specifies an assemblage of servers for targeting as a single unit for executing commands. So your inventory file will be ~/kube-cluster/hosts, and you’re done adding two Ansible groups, namely the masters and workers, to it. This will aid you in specifying your cluster’s logical structure.

The master group comprises a server entry called “master”, listing the IP of the master node (master_ip). It also defines that Ansible will be the root user, running all the remote commands. 

Likewise, the workers group consists of not one but two worker server entries, namely worker_1_ip and worker_2_ip. They also define the Ansible as the root user.      

Step 2 – Install the Kubernetes’ OS dependencies

After setting up your workspace directory and Ansible inventory file, let’s proceed towards the next step. That is, installing the OS dependencies of Kubernetes using the yum package manager of CentOS. These dependencies are as follows:

Docker – it is a container runtime, meaning that it runs your containers. Kubernetes is currently busy developing support for other runtimes like rkt.

kubeadm – it is a Command Line Interface (CLI) tool that helps to install and set up different cluster components.

kubelet – it is a system service running on all the nodes. Plus, it deals with node-level operations.

kubectl – This is another CLI tool that helps purvey commands to the cluster via its API server.        

Now, generate a new file, namely ~/kube-cluster/kube-dependencies.yml, in your workspace using this command:

vi ~/kube-cluster/kube-dependencies.yml

Next, add the below plays to the file you’ve just created to install these packages to your system:

~/kube-cluster/kube-dependencies.yml

– hosts: all

  become: yes

  tasks:

   – name: install Docker

  yum:

    name: docker

    state: present

    update_cache: true

   – name: start Docker

  service:

    name: docker

    state: started

   – name: disable SELinux

  command: setenforce 0

   – name: disable SELinux on reboot

  selinux:

    state: disabled

   – name: ensure net.bridge.bridge-nf-call-ip6tables is set to 1

  sysctl:

   name: net.bridge.bridge-nf-call-ip6tables

   value: 1

   state: present

   – name: ensure net.bridge.bridge-nf-call-iptables is set to 1

  sysctl:

   name: net.bridge.bridge-nf-call-iptables

   value: 1

   state: present

   – name: add Kubernetes’ YUM repository

  yum_repository:

   name: Kubernetes

   description: Kubernetes YUM repository

   baseurl: https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64

   gpgkey: https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg

   gpgcheck: yes

   – name: install kubelet

  yum:

     name: kubelet-1.14.0

     state: present

     update_cache: true

    – name: install kubeadm

  yum:

     name: kubeadm-1.14.0

     state: present

   – name: start kubelet

  service:

    name: kubelet

    enabled: yes

    state: started

– hosts: master

  become: yes

  tasks:

   – name: install kubectl

  yum:

     name: kubectl-1.14.0

     state: present

     allow_downgrade: yes

The first play performed lots of stuff, including installing Docker and starting the Docker service, disabling SELinux as Kubernetes doesn’t support it fully yet, etc. It also adds Kubernetes yum repository to the repository of your remote server, installs kubelet and kubeadm, and defines some netfilter-related sysctl values vital for networking.

On the contrary, the second play does only one job, that is, installing kubectl on your master node.

Save the file and quit once you’re done doing all this. Then, execute the playbook utilizing the below command:

ansible-playbook -i hosts ~/kube-cluster/kube-dependencies.yml

Once you’re finished, you will receive an output that will look something like this:

Output:

PLAY [all] **** 

TASK [Gathering Facts] ****

ok: [worker1]

ok: [worker2]

ok: [master] 

TASK [install Docker] ****

changed: [master]

changed: [worker1]

changed: [worker2]

TASK [disable SELinux] ****

changed: [master]

changed: [worker1]

changed: [worker2]

TASK [disable SELinux on reboot] ****

changed: [master]

changed: [worker1]

changed: [worker2]

TASK [ensure net.bridge.bridge-nf-call-ip6tables is set to 1] ****

changed: [master]

changed: [worker1]

changed: [worker2]

TASK [ensure net.bridge.bridge-nf-call-iptables is set to 1] ****

changed: [master]

changed: [worker1]

changed: [worker2]

TASK [start Docker] ****

changed: [master]

changed: [worker1]

changed: [worker2]

TASK [add Kubernetes’ YUM repository] *****

changed: [master]

changed: [worker1]

changed: [worker2]

TASK [install kubelet] *****

changed: [master]

changed: [worker1]

changed: [worker2]

TASK [install kubeadm] *****

changed: [master]

changed: [worker1]

changed: [worker2]

TASK [start kubelet] ****

changed: [master]

changed: [worker1]

changed: [worker2]

PLAY [master] *****

TASK [Gathering Facts] *****

ok: [master]

TASK [install kubectl] ******

ok: [master]

PLAY RECAP ****

master                     : ok=9 changed=5 unreachable=0 failed=0  

worker1                    : ok=7 changed=5 unreachable=0 failed=0 

worker2                    : ok=7 changed=5 unreachable=0 failed=0   

After the playbook execution, your remote servers will have Docker, kubelet, and kubeadm on them. The kubectl is not an essential element and deems necessary only when you try to execute the cluster commands. Therefore, installing it only on the master node is more than enough as you’re not going to run kubectl from anywhere other than the master node. Nonetheless, it doesn’t imply that you can’t run it from the worker nodes. It’s just that doing so would be unnecessary; that’s all.

All the OS dependencies are ready to roll now. So, let us configure the master node and inaugurate the cluster.

Step 3 – Set up the master node

This step is about setting up the master node. Before proceeding further and generating any playbook, it’d be best if you knew about pods and pod network plugins. Why? It is because both these things would be included in your cluster.

Pods are atomic units that run one or several containers. All these containers tend to share resources like network interfaces and file volumes. Therefore, pods are the essential unit in Kubernetes.

Every pod comprises a unique IP address. A pod on a particular node is capable of accessing another pod on some other node utilizing its IP address. Thus, containers on a particular node can communicate via a local interface with ease. On the contrary, communication between pods is noticeably more difficult and often requires the intervention of a separate networking component. The component should be capable of routing traffic between pods residing on different nodes.

Pods network plugins offer such functionality. For our cluster, we’re going to use Flannel, which is an efficient and stable option.

First, generate an Ansible playbook called master.yml on your PC:

vi ~/kube-cluster/master.yml

Add the below play to the newly created file for initializing the cluster and installing Flannel:

~/kube-cluster/master.yml 

– hosts: master

  become: yes

  tasks:

– name: initialize the cluster

   shell: kubeadm init –pod-network-cidr=10.244.0.0/16 >> cluster_initialized.txt

   args:

     chdir: $HOME

     creates: cluster_initialized.txt

– name: create .kube directory

   become: yes

   become_user: centos

   file:

     path: $HOME/.kube

     state: directory

     mode: 0755

– name: copy admin.conf to user’s kube config

   copy:

     src: /etc/kubernetes/admin.conf

     dest: /home/centos/.kube/config

     remote_src: yes

     owner: centos

– name: install Pod network

   become: yes

   become_user: centos

   shell: kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml >> pod_network_setup.txt

   args:

     chdir: $HOME

     creates: pod_network_setup.txt          

Let us break the entire play down:  

  • The first task runs kubeadm init and helps initialize the cluster. It also passes the argument, namely –-pod-network-cidr=10.244.0.0/16, specifying the private subnet from which the pod IPs will be allocated. By default, Flannel utilizes the subnet mentioned above. Therefore, we will tell kubeadm to use the same subnet.
  • The second task helps generate a .kube directory at your home/centos. This .kube directory will contain your configuration info, including your admin key files. These files are essential for connecting to the cluster and its API address.
  • The third task duplicates the file, namely /etc/kubernetes/admin.conf, created from your kubeadm init to the home directory of your centos user (non-root). Such duplication will empower you to access the cluster using the kubectl.
  • The fourth/final task runs kubectl apply. Doing so helps it install Flannel. The syntax kubectl apply -f descriptor.[yml|json] helps tell kubectl to make the objects defined in descriptor.[yml|json. The definitions of objects needed for configuring Flannel in the cluster are contained in the kube-flannel.yml file.

Save the file and quit once your work is done.

Next, execute the playbook using the following command:

ansible-playbook -i hosts ~/kube-cluster/master.yml

Upon successful execution, you will receive the following output:

Output:

PLAY [master] ****

TASK [Gathering Facts] ****

ok: [master]

TASK [initialize the cluster] ****

changed: [master]

TASK [create .kube directory] ****

changed: [master]

TASK [copy admin.conf to user’s kube config] *****

changed: [master]

TASK [install Pod network] *****

changed: [master]

PLAY RECAP ****

master                     : ok=5 changed=4 unreachable=0 failed=0   

You may put the master node through a status checkup by SSHing into it:

ssh centos@master_ip

Once you’ve entered the master node, execute the following:

kubectl get nodes

You will receive an output that will look something like this:

Output

NAME  STATUS ROLES     AGE   VERSION

master Ready master    1d    v1.14.0  

The above output signifies the master node has finished all the tasks related to initialization. It also signifies that the master node is now ready to begin accepting worker nodes and execute tasks consigned to the API server.

Step 4 – Configure the worker nodes

Now that you’ve finished Step 3, it’s time to set up the worker nodes. One can add workers to a cluster by executing a separate command for every node. This command encompasses vital cluster info, including the IP address, a secure token, etc. Any node failing to pass in the security token won’t be allowed to join the cluster.

Return to your workspace and generate a playbook with name workers.yml:

vi ~/kube-cluster/workers.yml

Now, add the below text to the newly-generated file for adding the worker nodes to your cluster:

~/kube-cluster/workers.yml

– hosts: master

  become: yes

  gather_facts: false

  tasks:

– name: get join command

   shell: kubeadm token create –print-join-command

   register: join_command_raw

– name: set join command

   set_fact:

     join_command: “{{ join_command_raw.stdout_lines[0] }}”

– hosts: workers

  become: yes

  tasks:

– name: join cluster

   shell: “{{ hostvars[‘master’].join_command }} –ignore-preflight-errors all  >> node_joined.txt”

   args:

     chdir: $HOME

     creates: node_joined.txt

Here’s a breakdown of the playbook’s functions:

  • The first play receives the join command necessary to run on the worker nodes. This command will be portrayed in a format like this – kubeadm join –token <token> <master-ip>:<master-port> –discovery-token-ca-cert-hash sha256:<hash>. After receiving the real command containing the apt hash and token values, the process enables you to access that information.
  • The second play only possesses one goal. It is to run the join command on every worker node in existence. Once this task is completed, the two worker nodes/servers will become members of the cluster family.

Now, save the file, close it, and proceed to execute the playbook:

ansible-playbook -i hosts ~/kube-cluster/workers.yml

Once you’re finished doing so, you will get an output like this one below:

Output:

PLAY [master] ****

 TASK [get join command] ****

changed: [master]

TASK [set join command] *****

ok: [master]

PLAY [workers] *****

TASK [Gathering Facts] *****

ok: [worker1]

ok: [worker2]

TASK [join cluster] *****

changed: [worker1]

changed: [worker2]

PLAY RECAP *****

master                     : ok=2 changed=1 unreachable=0 failed=0  

worker1                    : ok=2 changed=1 unreachable=0 failed=0 

worker2                    : ok=2 changed=1 unreachable=0 failed=0    

Now that the worker nodes/servers are added to your cluster, it’s now fully configured and operational. The workers are now capable of running workloads. However, before proceeding to schedule apps, we got to verify whether the cluster is working properly or not.

Step 5 – Verify the cluster   

Verifying a cluster’s workability is an important aspect to consider if you wish to install Kubernetes on CentOS 7. Why? Because clusters can sometimes face failure during configuration. The reasons behind this could be a node/server being down, the absence of a stable connection between the master and the workers, and so on. No matter the reason, it is crucial that you check the cluster and ensure that the nodes are working fine.

For that purpose, you will have to test your cluster’s present state from the master node. It will help you ensure the nodes’ readiness. In case you lost connection with your master node, you may SSH back into it using this command:

ssh centos@master_ip

After doing so, utilize the below command to receive details about your cluster’s status:

kubectl get nodes

Once executed successfully, you will get the following output:

Output:

NAME  STATUS ROLES     AGE   VERSION

master Ready master    1d    v1.14.0

worker1   Ready <none> 1d        v1.14.0

worker2   Ready <none> 1d        v1.14.0

Notice the STATUS section of the output. Suppose all your node values are showing Ready. In that case, it signifies that they’re a part of your cluster and are capable enough of running workloads.

On the contrary, if you notice some of the nodes having NotReady as their STATUS, it indicates that there is a problem. Such an output signifies that the worker nodes are not configured properly yet. Wait for some time (preferably 5-10 minutes) and then rerun the kubectl, get nodes and see what the new output has to offer. If the status is still Not Ready for a few nodes, you might need to resort to verifying and rerunning the commands mentioned in Steps 1 to 4.

Provided that your cluster had a successful verification and returned positive status, it’s time for some real action, that is, scheduling a demo Nginx app on your cluster.

Step 6 – Run an application on your cluster

Once you’ve done following all the above steps, now you’re capable of deploying any containerized app to your cluster. To ensure that things stay in your familiar zone, you may deploy Nginx utilizing Deployments and Services. You can also use the commands that are about to be mentioned below in the case of other containerized apps. Nonetheless, you must modify the Docker image name and any pertinent flags like volumes and ports.

Now, inside your master node, generate a deployment, namely nginx, using the following command:

kubectl create deployment nginx –image=nginx

Deployments are types of Kubernetes objects that ensure there’s always a set number of pods running based upon a defined template. That remains the truth even when the pod goes down somehow.

Next, utilize the below command to generate the nginx service. This service will help bring out the app in the open. For this purpose, it will utilize a Nodeport – a scheme for making the pod accessible via a random port created on the cluster’s each node:

kubectl expose deploy nginx –port 80 –target-port 80 –type NodePort

Services are different kinds of Kubernetes objects. They help to expose the internal services of a cluster to both external and internal clients. They are also proficient at loading balancing requests to various pods and are an essential element of Kubernetes. Besides, Services often interact with other components.

Now, run this command:

kubectl get services

The output you will get after doing so will look something like this:

Output:

NAME     TYPE    CLUSTER-IP   EXTERNAL-IP       PORT(S)    AGE

kubernetes   ClusterIP   10.96.0.1    <none>            443/TCP    1d

nginx        NodePort 10.109.228.209   <none>            80:nginx_port/TCP   40m

Notice the above output carefully. From here, you can find the port on which the Nginx is running. Kubernetes is known for auto-assigning an arbitrary port number greater than 30000. Besides that, it also ensures that the port is not being used elsewhere.

For testing out the workability of everything here, navigate to http://worker_1_ip:nginx_port or http://worker_2_ip: nginx_port using any browser. Doing so will take you to the welcome page of Nginx.

Removing the Nginx app is also possible. To do that, you got to eliminate the service from your master node:  

kubectl delete service nginx

Running the below command will help you make sure that the deletion was successful:

kubectl get services

You will obtain the below output:

Output:

NAME     TYPE    CLUSTER-IP   EXTERNAL-IP       PORT(S)    AGE

kubernetes   ClusterIP   10.96.0.1    <none>            443/TCP    1d

After that, delete the deployment using this command:

kubectl delete deployment nginx    

Finally, run the following command to check if the previous command worked right:

kubectl get deployments

The output will be:

Output:

No resources found.

With this step, you have successfully installed Kubernetes on CentOS 7.

Conclusion

In this guide, you learned the steps that allow you to install Kubernetes on CentOS 7 using Ansible and Kubeadm. After going through all the steps, you might’ve realized that these steps, while not being too tough, demand sufficient attention. Skipping any step or even a tiny bit of that step could mean disaster. From configuring the workspace directory and Ansible inventory file to running an application on your cluster – follow every step religiously. And, as we mentioned in Step 5, if your worker nodes fail to be ready to run workloads even after doing everything, there’s no easy way out. The only thing you could do then is to verify and rerun the commands mentioned in the previous steps. And, that’s something quite time-consuming and should better be steered clear of.

Learning to set up the cluster has its benefits too, including the freedom to deploy your own apps onto that cluster. Thus, research a bit and clear your concepts regarding Volumes, Secrets, Dockerizing applications, Ingresses, etc. All such info could help smoothen your way to the deployment of various production apps. Remember that Kubernetes is a treasure trove of functionality and features. Hence, the more you learn, the more of its potential you get to unlock.

Read more
06Jul

Dockerfile vs Docker Compose

July 6, 2022 admin Difference, Docker, Uncategorized

So you’re about to make your first move for deploying Containers? Now, you may be in a dilemma of choosing either the command line that allows you to deploy Containers one by one through long command options or use certain tools that enable you to set a predefined pattern for configuration files and then deploy containers with the help of short and quick commands.

Well, your decision here will determine the complexities associated with the application/service you are planning to deploy. However, everything boils down to whether you’re choosing dockerfile or docker-compose.yml. Docker Compose would be a common tool for either of the two option. However, you can also opt for choosing both dockerfile or docker-compose.yml, and still, Docker Compose would be required. You can use docker-compose.yml so that it will call upon a Dockerfile to let you create even more complex container rollouts. But before learning that, let’s clear some basics.

How is Docker Containers Created?

For creating Docker containers, you first need to build Docker images that act as a set of instructions. These images are built using dockerfiles that are text-based scripts. All the text files inside the dockerfile are composed of all the commands used for running Containers through Docker image.

Docker image allows individuals to have various users function parallelly under one environment. For sharing Docker images defined with instructions, users can simply upload it on Docker Hub where it can be accessed via the official public Docker Hub website. Any individual can pull these Docker images to build Containers that are consistent with the original Docker Containers.

What is Docker Compose?

Docker Compose is a tool that defines and runs multi-container Docker applications. It makes use of YAML files for configuring the services for the applications. Right after this, a single command is executed for running the services of containers. Docker Compose efficiently runs in every environment such as production, staging, development, testing, and even in CI workflow.

For better understanding, let’s take the example of eCommerce websites. First, users visit the website through internet browsers and perform actions such as logging in, browsing catalogs, adding products to cart, checking out, etc. To successfully execute these activities, various microservices run behind the scenes. These microservices function by running on services in their respective containers. However, developers have to ensure proper collaboration of these containers and this is where Docker Compose plays its role.

It helps in running various containers as a single service and eventually builds proper collaborations among them. Indeed, these containers will work in isolation but will be enabled to collaborate whenever required. Docker Compose files are written easily with the help of a scripting language called YAML, which is a Markup Language. One of the most important benefits of Docker Compose is that it enables users to activate services through a single command. Following are the three simple steps for operating Docker Compose:

  1. Defining the application’s environment through Dockerfile for it to be reproduced in any infrastructure and environment.
  2. Defining services offered by the application in docker-compose.yml to make them function in isolated environments.
  3. Execute docker-compose up command for making your containers get deployed and start functioning. Else, you can run docker-compose up using the docker-compose binary.

Features of Docker Compose

1. Preserving data volume

Docker Compose is efficient in preserving the volume for the services. Right after functioning, it checks the containers from previous runs and copies the volume from old containers to the new ones. Therefore, the data created into those volumes also get conserved.

2. Recreating containers

Docker Compose is used for caching configurations used for creating new containers with old features. On re-starting unmodified services, the existing containers get used for lesser load and quick start. In addition, users would be able to make modifications in their environment quickly.

3. Development environments

For developing software, an individual needs to run applications that are in isolation from each other for better functioning. The Docker command line can be used for achieving the same along with enabling containers to interact with each other at times.

In addition, by making use of the Compose command-line tool an individual can create one or more than one container through a single command, that is docker-compose up.

4. Automated testing environments

Docker Compose enables the Continuous Deployment or Continuous Integration process that eventually results in an automated test suite. Compose offers a testing environment and provides a simpler way to create and destroy isolated testing environments quickly.

What is Dockerfile?

Docker images are built automatically by following the description and details mentioned in the Dockerfile. It is a document containing text commands that users execute on the command line and then create images. Further, an individual can also run the “docker build” command for automatically building images with required commands. The images then created would be assigned with proper context. Context is a set of files specified at certain locations such as PATH or URL. The PATH is the directory of the filesystem stored on your computer locally. Whereas, the URL is the location at Git repositories.

For using files in the build context, the Dockerfile fetches the file which is defined properly with any instruction, such as the COPY instruction. For increasing the docker build’s performance, excluding files and directories by adding a .dockerignore file within the context directory is suggested. Typically, Dockerfile is situated at the root of the context. However, by using the -f flag with the docker build command, an individual would be able to locate a Dockerfile anywhere in the file system.

$ docker build -f /path/to/a/Dockerfile

Main Instructions of the Dockerfile

1. FROM

This instruction is used for analyzing new build stages along with setting base images for succeeding instructions. Every ideal dockerfile is created with the FROM instruction at the start. This instruction can be used with any docker image and it would be simple for users to get started if they pull images from Public Repositories.

FROM [–platform=<platform>] <image> [AS <name>]

Or

FROM [–platform=<platform>] <image>[:<tag>] [AS <name>]

Or

FROM [–platform=<platform>] <image>[@<digest>] [AS <name>]

2. RUN

The RUN command will carry out commands present in the new layers of current docker images for processing the results. The resulting image would further be used in the next steps of the Dockerfile.

The addition of RUN instruction will generate images that will obey all the basic concepts of Docker. In addition, the containers will be enabled for being created from any point in the image’s history. Its function is somewhat similar to source control that stores all the previous versions that can be rolled out at any point in time.

RUN has 2 forms:

  • RUN <command> (shell form, the command is run in a shell, which by default is /bin/sh -c on Linux or cmd /S /C on Windows)
  • RUN [“executable”, “param1”, “param2”] (exec form)

3. CMD

CMD instruction is created for providing default configurations to existing Containers. The default configurations can be executed and omitted and users have to specify ENTRYPOINT instructions along with it. A dockerfile can only have one CMD. But if there’s more than one CMD, then only the last one will function.

If CMD is utilized for providing default configurations to the ENTRYPOINT, then instructions for both CMD and ENTRYPOINT would be defined by JSON array format. CMD command has the following three patterns:

  • CMD [“executable”,”param1″,”param2″] (exec form, this is the preferred form)
  • CMD [“param1″,”param2”] (as default parameters to ENTRYPOINT)
  • CMD command param1 param2 (shell form)

4. LABEL

This instruction is used for adding metadata to Docker images. LABEL is a key-value pair and for including spaces while writing this command, an individual has to insert quotes and backslashes. Following is an example of the format for executing this instruction:

LABEL <key>=<value> <key>=<value> <key>=<value> …

Docker images can have multiple LABELs that are specified through single lines. In older versions of Docker, this instruction also reduces the size of the image, but this feature is removed in the recent versions.

Docker Compose Vs Dockerfile: What’s the Difference?

The difference between these two Docker terminologies is extremely easy to figure out. A Dockerfile is simply a text file that is composed of certain commands for enabling users to create the Docker image, whereas Docker Compose is a tool that defines and runs applications based on multiple containers.

Docker Compose is used for defining services that are used for making applications in docker-compose.yml, which helps them to function collaboratively in isolated environments. Therefore, an application would be able to function seamlessly by the execution of just one command, i.e. docker-compose up. Docker Compose further makes use of Dockerfile if the build command is added into the docker-compose.yml file. For every Docker image created, there has to be one suitable Dockerfile associated with the same. Then the compose assembles all the images for building Containers. Following is an example of a Dockerfile.

FROM centos:latest

LABEL maintainer=”collabnix”

RUN yum update -y && \

yum install -y httpd net-tools && \

mkdir -p /run/httpd

EXPOSE 80

ENTRYPOINT apachectl “-DFOREGROUND”

Conclusion

Using Docker for building Containers to run applications takes an individual through various steps. One such step includes the usage of Docker Compose and Dockerfile. These are used for different purposes while Deploying Containers but people often get confused with their usage. For understanding the key difference between the two, you should be well-versed with the complete process of how Containers are created and that is exactly why this blog starts with a brief overview of the Container creation process.

Nonetheless, you simply need to understand that Docker Compose is a tool that helps in defining and running applications with multiple Docker containers. It makes use of YAML files for configuring the services for the applications. Docker Compose efficiently runs in every environment such as production, staging, development, testing, and even in CI workflow. On the other hand, Dockerfile is a document that is composed of several text commands that are utilized by users for creating images.

Read more
24Jun

How to Install and Use PHP Composer on Ubuntu 20.04?

June 24, 2022 admin Uncategorized

The composer program is a PHP tool for managing project dependencies. Recently, it has become an extremely popular tool, and possibly the most effective as well. Follow this guide for complete instructions on installing and using PHP Composer on Ubuntu.

Before we begin with the step-by-step tutorial, let’s understand more about the basics.

What is PHP Composer?

Composer is a PHP project dependency management tool. It lets you stipulate the libraries your project relies on. It also installs or updates them.

Now, you will be thinking about what PHP is.

PHP is an acronym that stands for Hypertext Preprocessor. It is a prominent open-source scripting language. PHP is free to use, and its script runs on the server. Server-side languages like this are easy to use and are suitable for beginners.

It is efficient enough to be at the heart of the world’s largest blogging platform – WordPress! And it is sharp enough to power the biggest social networking site in the world – Facebook!

PHP files can contain HTML, Text, JavaScript, CSS, and PHP code. PHP files are indicated by the extension “.php.”.

PHP works on multiple systems, including Windows, Linux, Unix, Mac OS X, and is compatible with nearly all modern servers, notably Apache, IIS, and others.

PHP has been criticized previously for lacking a dependency management tool. Before the introduction of Composer, there had been unsuccessful efforts to establish a common PHP dependency management tool, such as PHPPM and Pyrus, which were designed to manage PEAR packages.

And finally, in 2012, PHP Composer was released as a package management tool to install and manage PHP modules. Following that, one can easily incorporate these modules into their project.

It assists users in installing the appropriate version of PHP modules within your app. It also keeps track of all the loaded modules and their versions. All entries are saved in a folder titled composer.json.

What is Ubuntu?

Well, this is an easy one. Ubuntu is a free Linux operating system with community and professional support.

Ubuntu is a community built on principles outlined in the Ubuntu Manifesto: that software should be free, that software tools should be accessible in any language and regardless of disability, and that people should be free to modify and customize their software in any way they like.

This guide will walk you through steps to install and configure PHP composer on Ubuntu 20.04 LTS systems.

Requirements:
  • Shell access to Ubuntu system that is up and running
  • Preinstalled PHP 5.3 or above on Ubuntu 20.04
  • You must have Sudo access and should be logged in as a non-root user.
  • Make sure your server’s firewall is powered on.

Let’s find out how to Install and Use PHP Composer on Ubuntu 20.04

Installing:

  • PHP has to be there on your PC for Composer to work. You might not have PHP installed. In that case, run the commands underneath to refresh your apt-cache and install PHP. Composer requires php-cli to run PHP scripts from the command line, as well as unzip to extract compressed packages.
  • Run the following command in your terminal to update the package manager cache:

$ sudo apt update

  • To install the needed packages use the command below

$ sudo apt install php-cli unzip

  • You’ll also have to install a few extra packages on your system. Use the shell to run the commands listed below.

$ sudo apt install unzip curl

  • After you’ve installed all of the essential packages, run the following command to check the existing PHP command line version:

$ php -v

  • Now, we’ll check to see if the downloaded installation matches the SHA-384 hash for the most recent installer, which can be obtained on the Composer Public Keys / Signatures page.

$ HASH=`curl -sS https://composer.github.io/installer.sig

  • If you prefer to verify the result, run:`

$ echo $HASH

  • Finally, perform the PHP code given on the Composer download page to ensure that the installation script is suitable to run

php -r “if (hash_file(‘SHA384’, ‘composer-setup.php’) === ‘$HASH’) { echo ‘Installer verified’; } else { echo ‘Installer corrupt’; unlink(‘composer-setup.php’); } echo PHP_EOL;”

  • Now, apply the next command to download the executable file of the composer to your PC.

$ curl -sS https://getcomposer.org/installer | php

  • Now execute the following commands to make Composer accessible to all users on your system so that all PHP programs on that system may use it.

$ sudo php composer-setup.php –install-dir=/usr/local/bin –filename=composer

  • Following the installation of the Composer on your PC. At the command terminal, type composer. This will give you the composer version as well as the options accessible with the composer command.

$ composer -v

Using:

A composer.json file is required to utilize Composer in any project. Composer uses the composer.json file to determine which dependencies to download for the project, as well as which versions of each package are authorized for installation. This is critical for maintaining the project’s relevance and preventing installation of fragile versions that may cause backwards compatibility issues.

You do not need to construct this file manually; doing so will almost certainly result in syntax errors. The composer provides an interactive mechanism for generating a new composer.json file depending on the user’s data, which is useful if you plan to distribute the project next as an unrestricted package on Packagist.

  • By using the same commands as during installation, you may obtain the latest versions of the Composer. The Composer is also capable of updating itself. To update the Composer, run the below-mentioned command.
  • Existing Project: Drive to the program root directory and administer the following command. It will read composer.json and install the application’s dependencies.

$ Composer install

  • New Project: To begin a new project, navigate the project directory and run the following command to install the necessary modules.

$ mkdir myapp && cd myapp

$ composer require psr/log

The command above will install the psr/log module in the vendor directory. It also adds an entry to composer.json and updates composer.lock.

Upgrading:

The Composer has the ability to upgrade itself. By executing a self-update, Composer will be brought up to date. Otherwise, you can get the most recent version of Composer by running the same commands you used to install it.

$ sudo composer self-update

Conclusion

Composers are becoming more popular as tools for managing project dependencies in PHP.

In PHP development, if norms are followed, better language could be developed. The composer has successfully resolved a critical issue in the PHP community, so there is no reason not to embrace it immediately.

We’ve covered the basics of Composer and how to install and use PHP Composer on Ubuntu.

We are hoping we’ve made your life a little easier!

Read more
09Jun

How to Set Up and Run Kafka on Kubernetes?

June 9, 2022 admin Uncategorized

Kafka is a key component of the Kubernetes cluster since it prepares a huge volume of data in real-time. Then there is Apache Kafka, which further improves the metrics of the data in the Kubernetes cluster. Apache Kafka is an event streaming platform created by LinkedIn that was initially developed as an open-source project. Linkedin donated the event streaming platform to the Apache software foundation and it changed the name of the Kafka to Apache Kafka. There are two native computer languages used on the platform, Java and Scala. Its most important mission is to provide high latency for handling real-time data.

Kafka is made of different APIs including Producer, the Connector and the Streams, the Consumer, etc. United, these APIs increase the latency level of platforms that maintain a high volume of real-time data. It runs as cluster nodes that we call Kafka brokers and is trusted by many well-known companies such as Uber, Airbnb, etc. Initially, Kafka was just a messaging queue for distributed systems that used to work as a pub-sub model as well. However, Kafka’s main motto now is to stream data on the internet on the behalf of the companies and also store a huge amount of information and keep the records of Kubernetes applications.

Generally, Kafka stores the messages in a sequence and divides them by topics. Kafka usually brokers data between systems or enables applications to respond to stream data in real-time. We need to deploy a fully-fledged Kafka cluster in Kubernetes. This approach helps us address the need for a message broker at the core of a large number of microservices. To ensure that the streaming data system does not fail, the number of Kafka instances across the nodes needs to be increased.

So, in this guide, we are going to show you exactly how to set up and run Kafka on Kubernetes so that there is no problem with streaming data and keeping a persistent volume of the data safely in the cloud storage.

How Does Kafka Work?

Apache Kafka is a vital virtual component of Kubernetes for the Kubernetes applications that are running on a cluster. The messaging system collects data and processes them in real-time no matter how voluminous it is. Kafka is, however, a publish-subscribe platform, which works as follows:

  • Producers create messages and divide them into topics and publish them.
  • Then Kafka categorizes those messages or determines their topics and stores them to make them immutable.
  • Then consumers search for the specific topics to become a subscriber and enjoy the messages producers are publishing.

Both producers and consumers serve applications that inform the consumers with messages regarding updates of the applications. These messages are stored and sorted by Kafka brokers based on user-defined topics.

Kafka configurations work with component management tools such as Zookeeper and Platform9 Free Tier. Kafka cannot work properly without Zookeeper because Zookeeper manages all Kafka components, including producers, brokers, cluster memberships, and consumers. Hence, we will first learn about Zookeeper and then delve deeply into Platform9 Free Tier information.

How to Deploy Zookeeper?

As discussed above, Kafka won’t work without Zookeeper so the first thing you should try is to deploy Zookeeper on your Kubernetes. Zookeeper should be deployed so that the Kafka service doesn’t keep restarting, but it can only be deployed by generating zookeeper.yml. This YAML file will schedule Zookeeper pods on the Kubernetes cluster for you, so you don’t have to do anything manually. Start the deployment by following the commands below. Copy and paste the following codes into zookeeper.yml using kublect or your preferred text editor.

apiVersion: v1

kind: Service

metadata:

name: zk-s

labels:

app: zk-1

spec:

ports:

– name: client

port: 2181

protocol: TCP

– name: follower

port: 2888

protocol: TCP

– name: leader

port: 3888

protocol: TCP

selector:

app: zk-1

—

kind: Deployment

apiVersion: extensions/v1beta1

metadata:

name: zk-deployment-1

spec:

template:

metadata:

labels:

app: zk-1

spec:

containers:

– name: zk1

image: bitnami/zookeeper

ports:

– containerPort: 2181

env:

– name: ZOOKEEPER_ID

value: “1”

– name: ZOOKEEPER_SERVER_1

value: zk1

After this, you will need to create a definition file and run kubectl create -f zookeeper.yml on your Kubernetes cluster. The next step is to create the Kafka service itself.

How to Create Kafka Service?

Here, we will create the Kafka service definition file that will manage the Kafka Broker deployments by balancing the data volume of Kafka pods. And you will find the following components on a primary kafka-service.yml file.

apiVersion: v1

kind: Service

metadata:

labels:

app: kafkaApp

name: kafka

spec:

ports:

–

port: 9092

targetPort: 9092

protocol: TCP

–

port: 2181

targetPort: 2181

selector:

app: kafkaApp

type: LoadBalancer

Save the file and create a service with the following code:

kubectl create -f kafka-service.ymlvh

Let’s move on to the next step to continue with setting up Kafka on Kubernetes.

Time to Define the Kafka Replication Controller

Generate another extra .yml file that will work as the replication controller for Kafka and the kafka-repcon.yml file will have the following elements:

—

apiVersion: v1

kind: ReplicationController

metadata:

labels:

app: kafkaApp

name: kafka-repcon

spec:

replicas: 1

selector:

app: kafkaApp

template:

metadata:

labels:

app: kafkaApp

spec:

containers:

–

command:

– zookeeper-server-start.sh

– /config/zookeeper.properties

image: “wurstmeister/kafka”

name: zk1

ports:

–

containerPort: 2181

Now, save the file and create it with kubectl create -f kafka-repcon.yml before going on to start the Kafka server.

How to Start the Kafka Server?

You will find the configuration settings of the Kafka server in the config/server.properties file. And since configuring the Zookeeper server is done at the beginning of the article, you can start the Kafka server right away with the following command:

kafka-server-start.sh config/server.properties

Once you have started the server, it is time to create a Kafka Topic. Like Kubernetes, Kafka has a command-line utility tool as well and it is known as kafka-topics.sh. You can create new topics on the server with this utility tool.

Next open a new window and copy and paste the command written below:

kafka-topics.sh –create –zookeeper localhost:2181 –replication-factor 1 –partitions 1 –topic Topic-Name

The topic’s name is Topic-Name, which has one partition plus a replica instance. We will now proceed to setting up a Kafka producer.

How to Start a Kafka Producer?

You will find the broker port ID in the config/server.properties file. In this context, the broker that we have used is listening to port 9092 and you can use the following command to specify the listening port directly:

kafka-console-producer.sh –topic kafka-on-kubernetes –broker-list localhost:9092 –topic Topic-Name

You can use the terminal window to attach a few messages and that will be pretty much how the reports will be generated on Kafka. Now it is time to create a Kafka consumer.

How to Begin a Kafka Consumer?

You can find the default consumer configurations in the config/consumer.properties file along with the producer properties.
To get the messages for Kafka consumer, open a new terminal window and paste the following command:

kafka-console-consumer.sh –topic Topic-Name –from-beginning –zookeeper localhost:2181

Here the –from-beginning command will specify the messages in order. Even when you access information or texts from the producer’s terminal, they will appear in the consumer’s terminal.

Go ahead and learn how to scale the Kafka cluster next.

Scaling the Kafka Cluster

Scaling your Kafka cluster is easy with the kubectl scale rc kafka-rc –replicas=6 command on the kubectl to make the cluster an administrator of Kubernetes. The process involves extending the number of pods from 1 to 6.

Somethings to Consider While Running Kafka on Kubernetes

By running Kafka on Kubernetes, you can simplify the operations such as scaling, restarts, upgrades, and monitoring the Kubernetes applications. Although there are some points you should consider while running Kafka on Kubernetes.

Low Latency Network and Storage

Kafka requires low latency and high storage that also refers to having low contention for information and high throughput. It helps Kafka to deliver fast media to brokers so that they can access the data locally and in the system where the pod is running. Therefore, it improves the overall system performance.

Availability of Kafka Brokers Should be High

The Kafka brokers can be deployed throughout the Kubernetes cluster. Brokers then connect users over fault domains. As Kubernetes can automatically correct pods when nodes and containers crash, it can also correct brokers when they go down. The high availability of brokers in Kafka Kubernetes cannot be ignored. However, one thing to consider about these brokers is what happens to the information that Kafka stores? To make sure if the data is following the pod, you need to apply a data replication strategy. You will be able to use different brokers for a higher throughput, which will also help you quickly recover damaged brokers.

Data Protection and Security

Before you Set up and Run Kafka on Kubernetes, you need to know the data protection and data security systems of Kafka. Kafka provides multiple replications of topics and monitoring of data across Kubernetes clusters. So, replication is like a backup that protects the data. When something fails in the cluster such as a node, the replication will back up the data. Likewise, mirroring of data makes the data prepared in other data centers.

There is also an in-built data security system in Kafka that implements various authentication systems such as using SSL among brokers. So, these data and filesystems are protected from manipulators or hackers on the internet.

Conclusion

We have now explained how to set up and use Kafka with Kubernetes. All you need to do is follow every step starting with deploying Zookeeper. If you are looking for a tutorial on how to set up the Platform9 Free Tier Cluster specifically for running Kafka on Kubernetes, we encourage you to check out our other posts. The rest of the information can be found in this tutorial, which will help you create the Kafka service and run the Kafka server on Kubernetes without any hassle.

You should remember that Kafka is an extremely powerful tool that’s used and supported by numerous companies, including Spotify, Coursera, Netflix, and many more. To improve the value of your organization and run complex microservices on Kubernetes clusters, you will definitely need Kafka. If any of these codes and command lines appear difficult to follow, please feel free to ask us for assistance. Furthermore, each of your comments will be responded to shortly.

Read more
30May

What is NumPy Package and How to Install it?

May 30, 2022 admin Uncategorized

Python refers to the integrated high-level general-purpose programming language with an emphasis on code readability i.e. identifying what the code is doing. Out of the many lucrative features of the Python programming language, a major feature is Python packages.

Several python packages can be installed by the users as per their preference and requirements. Python packages refer to the directory or the library that consists of python scripts. One such highly used python package is ‘NumPy’.

What is the NumPy Package?

NumPy refers to the open-source library for scientific computing in Python used by developers to work with matrices and arrays, especially multidimensional arrays and the derived objects, including masked arrays. NumPy helps developers to execute fast operations on arrays as input for the following operations:

  1. Logical operations
  2. Mathematical
  3. Sorting, and selecting
  4. I/O
  5. Basic linear algebra
  6. Simulation, and many more

Now, the question of greater concern is how to install the NumPy. So, in the next sections, we are going to detail the stepwise procedure to install the NumPy and the system requirements for doing so.

System Requirements for Installing NumPy

Before starting NumPy installation, the users need to fulfill certain prerequisites. Failing to meet these requirements will result in some errors. The prerequisites for installing the NumPy package are as follows:

  1. The updated version of the operating system.
  2. A version of Python installed and ready-to-use.
  3. Identify the version of the Python software installed on the device.
  4. A properly working cmd or terminal.

Steps to Install the NumPy Package

1. Check the Version of Python Installed On the System

Before installing NumPy, users need to check the version of Python they have on their device. In some systems, the programming language environment comes pre-installed. This is not the case with Windows though, so, here, the users need to install Python manually.

The latest version of Python is Python 3, however, Python 2 is also used widely. To determine the version of the Python software, enter the following commands to the terminal window or command-line:

(Important note: whenever you type a command within the terminal window or command line, press the ‘Enter’ key to complete its execution)

  • For Python 2: python –V (this will display the version in number as output)
  • For Python 3: python3 –V

2. PIP Installation

The easiest way of installing the NumPy library is by using pip, the default package manager responsible for maintaining and installing the software packages associated with the Python programming language.

Although pip comes pre-installed with Python, you can install it if it isn’t there. To install the default package manager, enter the following commands in the CMD:

  • For Pip (Python 2)

sudo apt install python-pip

  • For Pip (Python 3)

sudo apt install python3-pip

Both these commands are used along with the strong utility i.e. <strong> apt </strong>.

Once installation of pip is complete, enter the following command to verify whether the installation is successful or not:

  • <strong> pip –V</strong>

Else,

  • <strong> pip3 –V</strong>

3. Install NumPy

After the successful installation of pip, the system is ready for the installation of the NumPy library. To do so, utilize the commands detailed below within the terminal or cmd:

  • For installing NumPy for Python 2:

pip install NumPy

(This command ensures the download of the NumPy package through Pip and on its successful installation, the notification alert gets displayed on the screen).

  • For installing NumPy for Python 3:

pip3 install NumPy

4. Verification of the NumPy Installation

The verification process ensures that the NumPy library has been successfully installed on the device or that NumPy is now part of Python. To verify, use the commands as shown below:

  • For Pip2 type:

pip show numpy

  • For Pip3 type:

pip3 show numpy

The output of these commands will be a version of the NumPy along with the location where it has been installed, successfully.

5. Import of Packages Associated With NumPy

The import of packages associated with NumPy is one of the important steps, once the installation gets completed and set the alias for it. To import these packages, type the following commands within the terminal or command prompt:

<strong> python </strong>

<strong> python3 </strong>

To set an alias, type the following commands within the terminal windows:

<strong> python </strong>

<strong> python3 </strong>

How to Upgrade the NumPy Package?

The pip software that has been installed during the installation process (Step 2) can be used for upgrading the NumPy package to the device. The commands that need to execute to do so are as follows:

  • For upgrading NumPy version 2

pip install –upgrade numpy

  • For upgrading NumPy version 3

pip3 install –upgrade numpy

Conclusion

Python makes numerical computations easier with libraries and packages like NumPy. It is an important Python library. The aforementioned steps explain its installation using the pip package manager.

Read more
24May

How to quickly build a HELM Plugin quickly – A Complete Overview

May 24, 2022 admin Uncategorized

Helm is the package manager and an extraordinary addition to the Kubernetes ecosystem that manifests it by expressing it completely differently in charts and values. Helm is turned up with an assortment of curated Kubernetes applications that comply with the official chart’s repository. Sharing charts was a little hard because of the customizable parameters (values, YAML) being situated aloof. It is generally installed and built up in single graduation; that’s why there is no single location to view the resulting manifest.

Helm incessantly integrates through the Help plugin or an add-on tool and permits custom code to run easily and smoothly, even though it’s not a part of the Helm core code.

The importance of Helm

Helm is the main application package manager used by Kubernetes. It allows you to depict the application structure with a helpful helm-chart and manage it with whole orders.

Because there has been a significant change in how worker-side applications are classified, stored, and managed, the adoption of Helm is likely to be the path to mass adoption of microservices, as using this package manager greatly improves their administration.

What is the need for Helm, and why should we use it? Below are a few essential points?

  1. Helm is a tool that eases out your manual tasks effectively.
  2. It is more convenient to use in a command-line interface.
  3. The plugins are easily pluggable.
  4. It helps to enhance your everyday operation.
  5. You can create or build your own chart plugin at your convenience.

Features of Plugins

  • The Helm plugins are written in any language.
  • Without effect, the primary Helm core tool can be installed and removed.
  • They can integrate and turn up with Helm.
  • The plugins take up one’s abode in $Helm_Plugins.
  • You will find out its current value using the Helm env command, where the default value is not stable in a specific environment.
  • The plugins modules under Git plugins are modeled. On the one hand, they perform arbitrary actions and help provide either user experience or technological contention.

Creating a simple Helm plugin

The Helm plugin consists of a single important file (plugin.YAML).

It’s a point of entrance for Helm that redacts the command and setting of the plugin when it’s run and customized. There are three steps to creating a simple Helm plugin:

1. Create a new directory

When creating a plugin, we have to make a new directory to place your plugins.yaml with the below commands

name: “myplugin”

usage: “helm myplygin run”

description: |-

“Run myplugin on helm charts”

command: “echo The plugin is located in: \”$HELM_PLUGIN_DIR\” and its name is: \”$HELM_PLUGIN_NAME\””

2. Begin the installation from the file or directory;

$ helm plugin install.

  1. Executing the plugins

$ helm myplugin

A total illustration of a Helm module

The straightforward plugin model covers the most fundamental use cases and objectives that can be accomplished even with an assumed name. More complex issues require more coordination with Helm and more prominent adaptability of the plugin’s lifecycle. The accompanying parts will give you every one of the essential instruments to execute any rationale in the Helm stream.

Lifecycle customization: Install, refresh, and erase snares.

Helm provides under-documentation with the ability to guide into the module’s introduction.

update or uninstall orders.

hooks:

install: “cd $HELM_PLUGIN_DIR; ./scripts/install.sh”

update: “cd $HELM_PLUGIN_DIR; ./scripts/update.sh”

delete: “cd $HELM_PLUGIN_DIR; ./scripts/delete.sh”

Every hook relates to order and will execute the given script when conjured.

Some plugins might require a more complicated installation stream involving downloading a parallel dependent on OS design, building or gathering code, or essentially installing framework conditions. The introduction script is the spot to do it.

Execution integration

There are two different ways to indicate what will be executed and when:

Command:

command: “echo The plugin is located in: \”$HELM_PLUGIN_DIR\” and its name is: \”$HELM_PLUGIN_NAME\””

Platform command:

platformCommand:
os: linux
arch: i386
command: “echo The plugin is located in: \”$HELM_PLUGIN_DIR\” and its name is: \”$HELM_PLUGIN_NAME\”. The OS is linux and the arch is i386″
– os: linux
arch: amd64
command: “echo The plugin is located in: \”$HELM_PLUGIN_DIR\” and its name is: \”$HELM_PLUGIN_NAME\”. The OS is linux, and the arch is amd64″
platformCommand:
os: linux
arch: i386
command: “echo The plugin is located in: \”$HELM_PLUGIN_DIR\” and its name is: \”$HELM_PLUGIN_NAME\”. The OS is linux and the arch is i386″
– os: linux
arch: amd64
command: “echo The plugin is located in: \”$HELM_PLUGIN_DIR\” and its name is: \”$HELM_PLUGIN_NAME\”. The OS is linux, and the arch is amd64″

Note that Helm has a progressive system for picking the correct order:

  • ‘platformCommand(os+arch match)’
  • ‘platformCommand(os just match)’
  • ‘order’

The plugins of Helm aren’t executed in a shell, so the complicated commands should be necessary for a script executed each time the plugin is conjured.

A script can be utilized to run complex rationale, handle boundary parsing.

command: “$HELM_PLUGIN_DIR/scripts/run.sh”

A detailed illustration of a run script can be found easily. A beneficial thing that we can do is to deliver the chart and then execute the rationale on the subsequent Kubernetes YAML document:

helm template “${HELM_OPTIONS[@]}” > ${TEMP_MANIFEST_NAME}

$HELM_PLUGIN_DIR/bin/myplugin ${TEMP_MANIFEST_NAME} “${MYPLUGIN_OPTIONS[@]}”

A crucial flag in “plugin.yaml” is;

ignoreFlags: false

This banner indicates whether or not the order command line is sent to the plugin. If the plugin recognises boundaries, this setting should be set to false.

Tips and provisos

  • Numerous environment variables are exposed by Helm that can work on a tonne of perplexing rationale and give a significant part of the critical data and settings for the plugin’s execution.
  • The tunnel banner in config.YAML is deplored in Helm V3 and is presently not required.
  • To effortlessly test the plugin during improvement, you can introduce the plugin from the dev catalog by running ‘$helm module introduce PATH_TO_DIR.’ This is a common misunderstanding.
  • The plugin would then be able to be uninstalled with “$helm module uninstall PLUGIN_NAME.” This is a common misunderstanding.

Conclusion

Helm module composition is not difficult to adapt to, but it is hard to dominate. The absence of documentation makes managing complex modules a strenuous undertaking. The above-mentioned information will definitely uncover a portion of the lesser-known capacities of the Helm plugin system and give devices and platforms that eliminate the impediments of the plugin framework and permit the execution of as mind-boggling a business rationale as is essential to broaden Helm’s conduct.

Read more
23May

How to Use Git Push Force the Right Way?

May 23, 2022 admin Uncategorized

Title: How to Force Put in GiT – Complete Tutorial

Description: This article will help our readers understand the concept of Force Pushing and how to Force Put in Git.

Sometimes, you may experience local changes that are not compatible with remote modifications (i.e., you cannot move the remote branch forward, as the remote branch isn’t directly related to the local branch). The only method to drive your change is with a force push. And this will erase any changes made by the remote, so the remote will match the local.

The use of this command may cause the remote repository to lose commits. Furthermore, if you share this remote repository with anyone else, you should avoid using force push because the history of their repository will contain every written commit, which may render their work incompatible with the remote repository.

Don’t be afraid; every problem has a solution, and I’ll show you how to use the Force of Git to save time and energy.

What is Force Pushing?

Git stops you from overwriting the history of the central repository by denying push requests if they lead to non-fast-forward merging. If your remote history diverged from yours, it is necessary to take the remote branch out and merge it with your local repository before attempting to push again. And this is the same as the way SVN allows you to synchronize to the repository centrally by using the SVN update process before making changes.

The –force flag alters this feature and allows the remote repository’s branch to coincide with your local repository by deleting any changes that have taken place since you last pulled. The only reason you’ll ever have a push to be forced is if you realize that the changes you shared aren’t entirely correct, and you fix the issue using commit –amend in Git or an interactive Rebase. However, you should use the force option to ensure that none of your colleagues have already pulled those commits.

Why should one not use push –force?

It’s widely known that Git’s push-force option is highly discouraged since it could cause damage to other commits that have already been transferred into an open repository. It’s not always destructive (if the changes occur in the working tree of someone else, it could combine them); however, at a minimum, it’s unwise and at best dangerous. And this is due to the option to force the branch’s head to focus on your personal history and ignore any changes that might occur in conjunction with your own.

One of the most frequent reasons for force pushes is when we’re forced to change branches.

How to use it safely?

Because it’s straightforward to degrade or even hinder the work of your colleagues, here are a few “safety rules” around git push–Force:

Use it only for a shared history. If you’ve pushed commits on a branch shared with the team, try to avoid using the force push. If you’re on the other hand, it was on a feature branch, and if you are the only one using it, you are at ease to take a step onto the gas and choose the option to force.

Consider using git revert instead—the primary requirement for a tool to rectify a mistake you’ve already made remains. But, you should consider employing a tool that will not modify the history of commits using tools like git revert, as an instance. And this is an easier way to undo the mistake.

Choose force-with-lease over force. The push command comes with an additional option called “force-with-lease.” And this will ensure that you’re not rewriting others’ work by displaying an error message and will refuse to push if the remote has been modified since the last time you downloaded it.

How to Use –force-with-lease?

What it does is refuse to update the branch unless it’s in the state we would expect; i.e., there is no update to the branch downstream. In reality, this is done by ensuring that the downstream ref matches what we would expect, as refs are hashes that, in turn, encode the parent chain into their values.

It is possible to tell exactly what it should look for, but by default, it checks the remote ref currently in use. And this means that if you change the branch and transfer it to the remote repository, the ref pointing to this branch will be changed. So, unless your coworker pulls from the remote, their local reference to the remote is outdated. If they attempt to push with force-with-lease Git will compare the ref in the remote’s local file against the latest remote and deny the push. The force-with-lease option allows the force-push opportunity if another person has pushed changes to the remote during the time. It’s –force when the seatbelt is in place.

Force applies to all refs which are pushed, therefore using it in conjunction with push is recommended. It is set to match by using multiple destinations for the push that are configured using the remote. *.push can overwrite refs other than the currently used branch (including the local ones that lie purely behind their remote counterparts). To ensure that a push is only for one branch, put a + before the refspec you want to push (e.g., pull origin + master to make a push only to master).

Keep in mind to Use Force with Lease

If a regular push is not practical, it is unnecessary to force if they’re doing practical day-to-day tasks. Everyday needs are met by using the use of Force with a release. These are any Rebases. Specifically, the rebase of a branch on another branch, rewording an earlier commit or squashing a couple of commits together, reordering your commits, or changing the person’s name who wrote the previous commit.

Get back to your previous version after force Pushing

Imagine that you were working in a feature branch. You made some changes, made several commits, and finished your portion of the feature. You then transfer your changes to the primary repository. After that, you mash the commits together using Git rebase-I and then push the changes again using push –force. However, something went wrong, and you’d like to restore your branch to how it was before the rebase command -i. Now, the best feature of Git is that it’s essential not to lose data, which is why that version before the rebase is still accessible.

In this scenario, we’ll use the reflog command, which generates an extensive account of the repository’s history. Git makes a reference log entry for each “update” we do in our local repo. The git reflog command produces these ref-logs, which are saved within our local git repository. It reports every action that has altered branches’ tips, as well as any other reference to your own repositories, such as switching branches and rebasing.

The point of the branch is known as the “head” and is a symbolic reference for the active branch. It’s a symbolic reference because a branch is an identifier for commits.

Final Tip

Your collaborators may become out of sync if you forcefully modify the git history. Instead of changing existing commits, create a new one and push it without force. Force pushes are rarely required. It’s not a good way to practise.

There is one catch to this policy. If you’re working alone on a feature branch, forcing pushes have no effect on anyone else working on that branch. If you want to update the feature branch’s base, you must work on or edit specific commit messages and force-push those changes to the feature branch. Even when your feature branch is joined to the primary branch, the sync state cannot be lost.

Read more
10May

How to Perform Git Unstage for Files

May 10, 2022 admin Uncategorized

Git uses indexing to allow the developers to decide which codes they should include in the commit. For beginners, you can change the files using the `git add` and when you make a commit to the files, you will see the changes are automatically added. But when you mistakenly do improper indexing, and you don’t know how to bypass those changes completely, you can’t push them to the repo. But you need to do something with these changes so that they don’t go completely to waste. That’s where unstage comes in that refers to removing the changes of the files from staging. Let’s learn about indexing and unstaging files in Git from this post in a jiffy.

What is Index in Git?

In Git, we will find three stages of indexing. You need to create or change your files in a directory as you would do with the files that are on your hard drive. Then you should mention which changes you want to combine together. After that, take the changes, set them in a position, and describe them. And finally, you will create a commit that you can store in Git for future purposes. Indexing files are important because they help you to combine the changes together. When you are making changes to the commit, you need to pick the changes effectively. Index refers to a file stored in .git/index and when you create a commit, this file is reset to an empty state, and when you add more changes, those are added to the file. If you want to learn how to unstage the changes, you should get familiar with the commands `git reset` and `git rm`. Let’s talk about the ways you can unstage files on Git.

Unstaging Files on Git

Use the “git reset” command and mention the files that you should unstage from Git:

git reset <commit> — <path>

If you don’t designate the files, the parameter will go to HEAD. But the above command shall reset the index entries or the specifics that you have put in the staging area. You can add double dashes as argument disambiguation which means that the argument you are specifying has two different objects such as branches and directories. For instance, you have added a file that we call “README” to the staging and to unstage it, you will have to use the following command:

$ git status

On branch master

Your branch is up to date with ‘origin/master’.

Corrections to be performed:

(use “git reset HEAD <file>…” to unstage)

new file: README

To unstage the README file, you need to practice the instruction below:

$ git reset — README

Then check the status of your working directory using “git status”:

$ git status

On branch master

Your branch is up to date with ‘origin/master’.

Untracked files:

(use “git add <file>…” to include in what will be committed)

README

nothing added to commit but untracked files present (use “git add” to track)

So to remove files from index, you can apply the “git reset” command instead of the “git add” command which does exactly the opposite.

To Unstage All Files on GIT

In the first step, we have talked about how to unstage a file by its specific path or how to reset the file but sometimes you might have to unstage all the files at once from your index. To unstage all files, you can still use the “git reset” command without mentioning any specific path or filename:

$ git reset

The output will be this:

$ git status

On branch master

Your branch is up to date with ‘origin/master’.

Changes to be committed:

(use “git reset HEAD <file>…” to unstage)

new file: README

new file: directory/file

Use the “git reset” command to unstage all the files and directories from the staging section and put them back in the working directory.

$ git reset

$ git status

On branch master

Your branch is up to date with ‘origin/master’.

Untracked files:

(use “git add <file>…“ to include in what will be committed)

README

directory/

Not a thing included to commit but pathless files present (use “git add” to track)

Follow the next method to remove the unstaged changes on Git.

Removing Unstaging Changes on Git

Sometimes you might have to remove the unstage files from your staging area manually using the “git checkout” command and along with that, don’t forget to mention the specific paths that you want to remove:

$ git checkout — <path>

If there is a file that is not staged in your directory, you will see this output:

$ git status

On branch master

Your branch is updated with ‘origin/master’.

Changes not staged for commit:

(use “git add <file>…” to update what will be committed)

(use “git checkout — <file>…” to discard changes in working directory)

modified: README

no changes added to commit (use “git add” and/or “git commit -a”)

To remove the changes you have done to this unstaged file, you can use the “git checkout” command and mention the file name:

$ git checkout — README

$ git status

On branch master

Your branch is up to date with ‘origin/master’.

nothing to commit, working tree clean

However, if you want to remove your overall directory, go back to the root of the design and execute this command:

$ git checkout — .

$ git status

On branch master

Your branch is up to date with ‘origin/master’.

nothing to commit, working tree clean

In case you want to unstage commits only, then use the “git reset” command and add a “soft” option along and the commit hash as well:

$ git reset –soft <commit>

To unstage your last commit, Head it to revert to the previous version of the commit:

$ git reset –soft HEAD~1

The “soft” argument is stored in your working directory and index and your changes are always kept but they are not in the Git repo. When you check out your repo after executing a soft reset, you will get this output:

$ git status

On branch master

Your branch is up to date with ‘origin/master’.

Changes to be committed:

(use “git reset HEAD <file>…” to unstage)

modified: README

But if you hard reset your commit, all changes will be removed and you would use the “hard” command with “git reset” instead of “soft”.

$ git reset –hard <commit>

But when you are using the hard command, you will lose all your modifications and that’s why you should only apply it when necessary.

If you are using Git for years or for the first time, you should know that Git GUI also allows users to unstage files. Check out the next section to learn about Git GUI a little bit.

How to Unstage Files on Git GUI?

Many developers prefer to do commits using Git GUI but it is the easiest way to track all your changes. With the help of tcl-tk, you can see two lists in the dashboard of your Git GUI where you can find unstaged changes and the staged changes as well. You will find the changes you have added to the commit using ‘git add’ and you can also find the changes you have removed from the commit using ‘git rm’. Basically, the removed changes are found at the bottom of the list, and on the right side, you will find the current change of selected files and there you will also find a text area where you can add your own commit message. Git GUI is a fast command that allows you to view all the changes simultaneously and if you learn about shortcuts of GUI then the process will be easier.

  • You select files you want to stage or unstage and then press Ctrl+T/Ctrl+U to stage or unstage those files
  • Ctrl+I will stage all the files and will also ask you if you want to add new files
  • Ctrl+J is for reverting changes
  • Ctrl+Enter will help you perform a commit
  • Ctrl+P is for pushing the commit to the directory

So, if you don’t find unstaging and staging commits from the command line helpful or simple, then using graphical interfaces will help you to do so. But many people don’t like to use Git GUI because it does not look attractive and is a graphical application. So, it is up to you which process you are going to try to unstage or stage files on Git.

Conclusion

Let’s recap the whole process of Git unstage. Maybe you have created some junks in your working directory or added a new tool but accidentally staged some unwanted files to the Git repository. In that case, you can add those unwanted junks to your .gitignore file and unstage the changes that you have created. And this entire post only talks about how to unstage files of the Git repository through a few simple commands. Ensure that Git only adds the components that are not in the .gitignore files so that the unnecessary work doesn’t add up to your next commit. And since we have already talked about that in this post, you won’t have to worry about that too much.

Read more
10May

What is a Hypervisor? What Does it Do?

May 10, 2022 admin Uncategorized

The Role of Hypervisor

The Hypervisor is known as a virtual machine monitor (VMM) that separates operating systems from the computer hardware. Hypervisor comes in the form of software and is used in cloud hosting and divides the hardware resources of the computer operating systems into multiple pieces.

Using the hypervisor, a host system can share the virtual machine’s resources with other virtual machines. The resources can be anything varying from storage and services. But there is more to hypervisor than we can say in the introduction. So, let’s read this entire article and find out more about it.

What is a Hypervisor?

A hypervisor is a software that runs virtual machines or VMs, but it is also called a virtual machine monitor because it can quarantine the system resources from one virtual machine and allow developers to create and manage that virtual machine. The host is hardware that you use as a hypervisor technique that helps you run different operating systems as guests on a single host system simultaneously.
The hypervisor allows you to use more system resources and provide mobility to help you move the hardware components easily between different servers. A hypervisor can reduce the maintenance requirements of the virtual machines, their space, and energy. And that makes it easy for the hypervisor to run multiple VMs in a single physical server.

Now to know more about how hypervisors work, you will have to look into different types of hypervisors.

How many types of Hypervisors are there?

Hypervisors are implemented as a software layer in traditional terms, but they can also be performed as embedded codes in the machine’s firmware. And that creates two types of hypervisors: type 1 and type 2.

Type 1. Hypervisor

A hypervisor that runs on the host’s system is called a “Native Hypervisor” or “Bare Metal Hypervisor”. You do not require any operating system-based server to run it because it can directly access hardware resources. VMware ESXi, Microsoft Hyper-V hypervisors, etc., belong to this category. Type 1 hypervisor is an efficient hypervisor because it can directly access the CPU resources, physical storage, memory, network, etc., of a host machine.
This process is secure because there is no third-party resource involved that might compromise the security. But the only problem with type 1 is you will need a separate computer for performing its operations. You will also need to direct another virtual machine to allow it to control the hardware resources of the host.

Type 2. Hypervisor

Type 2 hypervisor is a host operating system that runs on another host system, and it does not run directly on the underlying hardware. Type 2 hypervisor runs as an application in the physical system, and you have to install that application to allow the hypervisor to create hardware calls. VMware Player is a type 2 hypervisor that you can install on your computer, and it helps in checking malware or viruses on your PC and other potential suspects.
Type 2 hypervisors grant you easy access to the guest operating system while running in the host machine at the same time. The type 2 hypervisor typically comes with additional features when you are using it on a guest machine. However, you cannot access physical hardware components from this type of hypervisor directly. And it also comes with some risks of security that attackers can find easily.

Now, between these hypervisors, you might have a hard time choosing the right one. To help you with that, we have created a separate section below.

How to choose the right type of Hypervisor?

Type 1 hypervisor is better than type 2 because there is no additional layer in it. Type 1 is immensely used in complicated application development and managing workloads. But type 2 is also useful in some cases. For example, the type 2 hypervisor is easy to set up, and it also helps you deploy a test environment efficiently. You can compare how efficiently these two work so that you can determine which of these hypervisors to choose from.

Understand your requirements: People use a virtualization hypervisor for flexibility, reliability, efficiency, usability, availability, scalability, support, etc. Before choosing between type 1 and type 2 hypervisor, make sure it’s offering what you are looking for.

Affordability: The cost-effectiveness of the system needs to be accounted for prior to buying it. A hypervisor’s functions should be balanced with its cost. Entry-level software is sometimes free, but they do have limitations and glitches. But licensed hypervisors are usually more proficient, so they are also more valuable.

How it performs: Virtual machines should be more proficient than physical machines, especially when there is software involved in the server. You should consider factors such as the number of CPUs a hypervisor is using, its maximum guest memory, and the processors it supports.

Ecosystem: Verify the documentation, training, support, third parties involved in developing the hypervisor software, as well as its availability, if it works, and its reliability.

Once you determine what you need a hypervisor for, you can certainly choose the suitable type for your company and personal use. But please make sure that the hypervisor provides the exact benefits that it is supposed to deliver.

What are the benefits of using a Hypervisor?

Firstly, you can allow your host machine to run different guest virtual machines simultaneously to improve the utilization of the hardware. While with the host machine, you can only host one operating system and one application, the hypervisor can help you virtualize the server so that your host machine can host multiple virtual machine instances. Each of these instances is running an individual operating system and application. And hypervisor allows these instances to do it from a single host machine and access more computing resources.

This is the primary reason and benefit of using a hypervisor. But the secondary benefit can be its flexibility. You can use hypervisors from a smartphone if it’s available as an Android or iOS version. So here are the benefits in a nutshell:

  • Reduces cost of using more hardware resources
  • Can easily and efficiently migrate a running virtual machine to a physical machine without transferring the VM to offline
  • The VMs are isolated so that a compromised virtual machine cannot be used to get inside another VM.
  • The Bare-metal hypervisor comes with a snapshot feature that can restore the VMs instantly to their previous state without performing a backup.

Conclusion

Hypervisors are important for organizations to create an extra layer between the data centre and the organizational environment. You only need to understand how the type of hypervisor you are using works and how to perform various management and controls for using the software. It may require you to know how to control management tasks, configurations, migrations, snapshots, etc.
The best hypervisors available in the market are Citrix Hypervisor, VMware ESXi, Oracle VM Server, and more. Some of them are pricey, and some of them are totally free. But the free ones might not meet your certain needs.

We are going to talk more about hypervisors and their different features and limitations in other blog posts. So, follow our site to know more about hypervisors.

Read more
29Apr

How to Check if a File or Directory Exists in Bash?

April 29, 2022 admin Uncategorized

If you are working with the bash system on your Linux or Unix computer, you might need to check if a file or directory exists in the bash. Most of the time, when you are working on the Shell scripts, you need to find out a specific file and directory before writing any more inputs in the scripts. But the easiest way to figure out the files or directories is by using some simple commands in the Bash. The commands will tell you if the file exists and what type of file it is that you are looking for. The commands contain these syntaxes:

test EXPRESSION

[ EXPRESSION ]

[[ EXPRESSION ]]

In this article, we are going to show you some simple ways to perform “Bash tests” using commands. For the starter, if you want to make a portable script, you can use the [ command that is available in the POSIX shells. It is an old file test method in the Linux system. But these days, we are using the [[ command to run the same type of bash test, which is a modern method that supports Bash, Zsh, and Ksh shell by default. So, check out the following sections to learn more about these commands.

How to Check if a File Exists in Bash?

-e and -f are the most commonly used file operators that will help you find if a file exists despite its type. With the -e command, you can find a file and with -f, you can find if the file is a regular file or a device or a new directory. Most of the time we use the test command to check if a particular file exists or not. We can use the test command with the if statement. In this example, we are checking if the /etc/resolv.conf file exists in the Bash. And the following commands will help us do that:

FILE=/etc/resolv.conf

if test -f “$FILE”; then

echo “$FILE exists.”

fi

FILE=/etc/resolv.conf

if [ -f “$FILE” ]; then

echo “$FILE exists.”

fi

FILE=/etc/resolv.conf

if [[ -f “$FILE” ]]; then

echo “$FILE exists.”

fi

You can use the if/then structure in the command to know if a file exists in the bash and it will help you perform a new action. For example, you were using the previous commands to install a new file. If you want to update the file, use this command to check if the update is already available or not:

FILE=/etc/resolv.conf

if [ -f “$FILE” ]; then

echo “$FILE exists.”

else

echo “$FILE does not exist.”

fi

Users can use the test command without the if statement. The command that comes after the && operator needs to be performed only when its exit status is true according to the test command:

test -f /etc/resolv.conf && echo “$FILE exists.”

[ -f /etc/resolv.conf ] && echo “$FILE exists.”

Copy

[[ -f /etc/resolv.conf ]] && echo “$FILE exists.”

We use the && as an AND list operator with this syntax: foo && bar. You can run a set of commands after the && operator and for that, you will have to use, or && and those commands will be closed into a third bracket:

[ -f /etc/resolv.conf ] && { echo “$FILE exist.”; cp “$FILE” /tmp/; }

In the command above, you can see && after a statement. If the status of the exists command is false according to the test, the && will have || operators opposite to them like this one in the example below:

[ -f /etc/resolv.conf ] && echo “$FILE exist.” || echo “$FILE does not exist.”

C

That’s how to check a file. But there are times when we need to check directories or multiple files in the Bash. Let’s see what commands we use for that.

Check if a Directory Exists

You can check if a particular file is in a particular directory or not by using the -d command. Here we are checking if the /etc/docker directory exists and for that, we have used the following command:

FILE=/etc/docker

if [ -d “$FILE” ]; then

echo “$FILE is a directory.”

fi

Copy

[ -d /etc/docker ] && echo “$FILE is a directory.”

You can use [[ instead of [. And -d is the short form for checking directories. But you can write the bash script mentioned below to check the bash directory in another way:

#!/bin/bash

if [[ -d /etc ]]

then

echo “/etc exists on your filesystem.”

fi

If the directory exists, the output will be:

$ /etc exists on your filesystem

That’s how you check a directory in the Bash system. But if you want to check multiple files, move on to the next section.

How to Check Multiple Files in Bash?

You could use complex if/else structures to seek files in the Bash. But using the -a and && with [[ will help you with checking multiple files more easily. This is how we have done it:

if [ -f /etc/resolv.conf -a -f /etc/hosts ]; then

echo “Both files exist.”

fi

Copy

if [[ -f /etc/resolv.conf && -f /etc/hosts ]]; then

echo “Both files exist.”

fi

You don’t have to use the if statement and the command will look like this:

[ -f /etc/resolv.conf -a -f /etc/hosts ] && echo “Both files exist.”

Copy

[[ -f /etc/resolv.conf && -f /etc/hosts ]] && echo “Both files exist.”

However, that’s how you check if files and directories exist in the bash. What if you want to know if a particular directory does not exist?

How to Check if a File Does Not Exist?

You will have to use the ! mark to check if a file does not exist in a directory:

FILE=/etc/docker

if [ ! -f “$FILE” ]; then

echo “$FILE does not exist.”

fi

If you want to use the short form, use this:

[ ! -f /etc/docker ] && echo “$FILE does not exist.”

However, you cannot keep checking every day if a particular file or directory exists in the bash. You can create a script instead that will automate the process. If the script does not find a file, it will notify you with a message. Here, we are going to create different file names and use them with the command to check if the test result returns them or not. Use the chmod and make an executable bash script:

$ mkdir -p ~/bin

$ cd ~/bin && touch check_file && chmod u+x check_file && vi check_file

The script will look like this that can check if the files exist in bash in a dynamic manner:

#!/bin/bash

# Using argument expansion to capture all files provided as arguments.

for FILE in ${@}

do

if [[ ! -f $FILE ]]

then

echo “The file ${FILE} does not exist!”

fi

done

Save the previous script and move the bin folder to your path variable so that it can be accessed from wherever:

$ export PATH=”~/bin:$PATH”

$ printenv PATH

~/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

Use this command to check if the file exists or not with the new script:

check_file /etc/passwd /etc/pass /etc/file

This new script will list out the files if they don’t exist. Replace the name of the file with etc mentioned in the above command.

File Operators

The word FILE means both files and directories. When we are using test commands, they contain several file operators that help you check for a specific type of file in Bash. Here are those file operators:

  • -L “FILE” : FILE exists and is a symbolic link (same as -h)
  • -h “FILE” : FILE exists and is a symbolic link (same as -L)
  • -d “FILE” : FILE exists and is a directory
  • -w “FILE” : FILE exists and write permission is granted
  • -x “FILE” : FILE exists and execute (or search) permission is granted
  • -r “FILE” : FILE exists and read permission is granted
  • -s “FILE” : FILE exists and has a size greater than zero

These operators will help you check the type of files and directories and compare their values.

Conclusion

We use the file operators to test different properties of a particular file on your Linux distro. A file operator will contain a filename that exists on bash and the operator uses the test command to check if the file exists. The size of these variables is 100 bytes and they have the read, write, and execute permissions for the files and directories in your bash. That’s why the commands we have provided in this article will help you check and figure out whether a particular file exists or not. If you are having any difficulty with this, feel free to ask us for help in the comment box below. Or you can also check out our other relevant articles for assistance.

Read more
    123
corporate-one-light
+1 800 622 22 02
info@scapeindustries.com

Company

Working hours

Mon-Tue

9:00 – 18:00

Friday

9:00 – 18:00

Sat-Sun

Closed

Contacts

3 New Orchard Road
Armonk, New York 10504-1522
United States
915-599-1900

© 2021 Kuberty.io by Kuberty.io