DEV Community: Kehinde Alade

Ansible Tutorial: Automate and Configure Remote Linux Servers

Kehinde Alade — Tue, 25 Oct 2022 16:45:36 +0000

What if you have to remotely automate Linux servers, maybe about 200? What options do you have? You could decide to use the following;

Shell
Python

If you have sufficient experience in programming, you can write a Shell script or a Python script to do that for you; what if you don't know Shell or Python? You'd have to learn either one. In most cases, you may not want to go through such stress.
In this tutorial, I will be explaining the process of automating using Ansible as you'd do to a beginner, but there are some requirements to follow;

Linux
Vagrant (The first article in this series)
YAML (You can learn at Ansible YAML)

That's just about all, let's dive right in 🎶

We have set up three Linux servers in Virtualbox using Vagrant; they all use the Ubuntu image.

Nodecontroller: This is the controller server where we'll Install Ansible.
target01: As its name implies, this is the target server, we'd be automating this server and target02.

Let's ssh into the nodecontroller and Install Ansible, we'd be following the guide at Ansible Installation Guide

CD into where you have your Vagrantfile, run vagrant status to verify the VMs we installed in the first article then;

vagrant up && vagrant ssh nodecontroller

It starts up the VMs AND ssh into the nodecontroller, now to install Ansible;

Run

sudo apt install ansible

If it can't find the package, go ahead and follow the instruction below, otherwise skip the adding the source list part;

echo deb http://ppa.launchpad.net/ansible/ansible/ubuntu trusty main >> /etc/apt/sources.list

It adds the ansible source to the sources list for Ubuntu if you see a permission denied error even with using sudo;

Run

su

Then run the same command and exit when done, next;

sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 93C4A3FD7BB9C367 
sudo apt update
sudo apt install ansible

This should take a few minutes, after it's done, to verify it has been installed, run;

ansible --version

You should see something like this, and then you're good to go;

Getting started with Ansible

Ansible has three main components, namely;

Control node: This is our nodecontroller.
Managed node: This is target01 and target02
Inventory: This is the list of our nodes organized on the control node, as it sounds, it stores the list of nodes we want to automate.

Let's create an Inventory

Get the IP addresses of target01 and target02 by vagrant ssh target01 into them from your host(PC), then run ifconfig, note them down and exit, and now SSH into your nodecontroller.

cat > inventory.txt

Then paste;

target01 ansible_host=192.168.56.4 ansible_ssh_pass=vagrant
target02 ansible_host=192.168.56.5 ansible_ssh_pass=vagrant

Press Enter, then Ctrl C to exit, then run cat inventory.txt to verify the input.

We added the target01 and target02 to the inventory file, the target01 and target02 are the name of the server, ansible_host is a variable, and we stored each server's IP address in it, ansible_ssh_pass stores the SSH password for each server, this shouldn't be used in production apps as it exposes your password.

Let's ping target01

Run

ansible target01 -m ping -i inventory.txt

You should see this output if it was successful;

If you can't, verify the IP address you used for target01, you can try pinging target02 too in the same way.

Now we've only tried connecting to a server only one at a time, using ansible target01 -m ping -i inventory.txt, we want to be able to run commands on multiple servers with a single command, let's edit our inventory file.

You can use nano or VIM to edit the inventory file, if you'd like to learn about the VIM editor, check out my article, VIM for beginners, or use nano, by running nano inventory.txt and edit the file to;

[targets]
target01 ansible_host=192.168.56.4 ansible_ssh_pass=vagrant
target02 ansible_host=192.168.56.5 ansible_ssh_pass=vagrant

Then Ctrl X to Save and Exit.

Now run;

ansible targets -m ping -i inventory.txt

You should see;

We got two outputs, this is from each target (target01 and target02).

Quick explanation

In the inventory.txt, we created a group called targets and added the target01 and target02 configuration; that's why we can run ansible targets -m ping -i inventory.txt and it runs on all servers under the targets group.

But there's a better way to automate tasks on Servers!

Introduction to Ansible Playbooks

Based on docs.ansible.com. Ansible Playbooks offer a repeatable, reusable, simple configuration management and multi-machine deployment system that is well suited to deploying complex applications. If you need to execute a task with Ansible more than once, write a playbook and put it under source control. Then you can use the playbook to push out new configurations or confirm the configuration of remote systems.

Let's create an Ansible Playbook

nano Ansible-play.yml

Paste this;

- name: Play one
  hosts: targets
  tasks:
    - name: "Execute IP Check"
      command: ifconfig
      register: command_output
    - debug : var=command_output

Then run the playbook and attach the inventory file to it;

ansible-playbook exampleplaybook.yml -i inventory.txt

Explanation

The whole YAML file is the playbook, under it, we have each play (activities/tasks that run on the server); we named it Play one, also we used targets as the hosts - This is our group from the inventory file, so we targetted all servers under the targets group. Then we have each task that will run in the server under the tasks list.

The first task explanation

- name: "Execute IP Check"
  command: ifconfig
  register: command_output

We gave it a name and used the command module to run the ifconfig command, then registered the output in a variable named command_output.

The second task explanation

- debug : var=command_output

We then used the debug module to redirect the command_output to the stdout of the host (your PC).

So, in summary, we ran all the ifconfig commands on all the servers under the targets group and got their outputs.

BUT there's a better way to copy files from a source(your PC) to a destination(nodecontroller) through SSH.
SCP is the solution.. 😉
I was hoping you wouldn't ask me the whole meaning; I forgot, lol.

How to use SCP

Secure Copy(SCP) is used to securely transfer files through the SSH protocol from one computer to another.

You want to be able to edit your Ansible playbook on your PC(host), so you can use a text editor like VSCode; when you're done editing it, you can transfer it to the nodecontroller VM with a single command instead of using that ugly nano or copying from your host to the VM, this is a better alternative and faster and we get to learn something more.

Install SCP Plugin in Vagrant

vagrant plugin install vagrant-scp

That's all; now we're ready to use SCP.

Format of the SCP command

vagrant scp <source> <destination>

In your host(PC), change the directory to where you have your ansible playbook, then run this command;

Using it;

vagrant scp absolute_uri_to_playbook/playbook.plays.yaml nodecontroller:/home/vagrant

This copies the playbook on your host to the nodecontroller using just a single command, so when you make new changes to the playbook on your host, rerun that same command; SCP is not only on Vagrant; you can also use it without Vagrant.

What are Ansible Modules?

Based on docs.ansible.com, Modules (also referred to as “task plugins” or “library plugins”) are discrete units of code that can be used from the command line or in a playbook task. Ansible executes each module, usually on the remote managed node, and collects return values.

We've used two modules so far; we used the command and the debug module, modules is the building block you build upon on playbooks, want to install apache on 250+ Ubuntu Linux server? Use the apt module for Ansible.

Install PHP/MYSQL and Apache on all VMs using Ansible Playbook

It's alright if you don't know PHP, follow along. Let's assume you have to configure the LAMP stack for about 200+ systems running Linux, you can do that using Ansible with a playbook; it takes just a single command.

Create a playbook in your nodecontroller and name it playbook.plays.yaml, you can name it anything you like.

In playbook.plays.yaml

- name: Play one
  hosts: targets
  tasks:
    - apt_repository:
        repo: ppa:ondrej/php
        state: present
      become: yes

    - name: Install Apache2
      apt:
        name: apache2
        state: present

      become: yes
    - name: Install MySQL Server
      apt:
        name: mysql-server
        state: present
      become: yes
    - name: Install PHP and others
      become: yes
      apt:
        pkg:
          - php5
          - libapache2-mod-php5
          - php5-mysql

NOTE: Don't use PHP5 on a production app; I only used it for illustration, I was having issues installing PHP7, so I had to go with the quick one.

Quick explanation

We used the targets group as the hosts, which contains target01 and target02. The first task we added adds the ppa:ondrej/php repository using the apt_repository module, we'd have used sudo add-apt-repository ppa:ondrej/php5 to do this on a terminal, we also used a field become: yes, this is used to elevate privileges, that is using sudo.

Then we used the apt module to install mysql-server, then used a field state: present, this means mysql-server should be present, if it was already installed, it does nothing, and if it wasn't installed, it installs it, so you can run this as many times as you want.

We did same for apache2, in the last module, we installed a list of packages, php5, libapache2-mod-php5, php5-mysql.

Now you can run it.

ansible-playbook playbook.plays.yaml -i inventory.txt

If it was successful, you should see something like;

This means you have installed PHP and MySQL on target01 and target02 without actually interacting with either of them, now imagine it was about 100 virtual machines.

There are more to working with Ansible to this, also our PHP and MySQL setup isn't done yet, I just went through the basics in this article, maybe, just maybe in the future, I might create a complete tutorial to do that.

This brings us to the end of this long article, I hope you enjoyed it, if you did, consider sharing and/or adding a Reaction, if you had any issues, you can also add a comment here, I would try my best to help.

Thanks for reading.

How to Create and Automate Virtual Machines using Vagrant

Kehinde Alade — Mon, 17 Oct 2022 10:01:42 +0000

Vagrant is an automation tool that helps in easily creating virtual machines and automating them while saving time and increasing productivity.

Based on https://www.vagrantup.com/intro, Vagrant is a tool for building and managing virtual machine environments in a single workflow. With an easy-to-use workflow and focus on automation, Vagrant lowers development environment setup time, increases production parity, and makes the "works on my machine" excuse a relic of the past.

Have you ever used VirtualBox or VMWare before? Vagrant helps us automate and quickly build the things you'd have used VirtualBox for; sounds easy, I know, right?

We'd be learning about Vagrant by using it with Ansible; what is Ansible?

Ansible is an IT automation tool. It can configure systems, deploy software, and orchestrate more advanced IT tasks such as continuous deployments or zero downtime rolling updates.

Ever thought of writing a script to automate something for you using Python or Golang? Ansible helps you do that without writing actual codes; YAML is the language ansible understands.

Even though I've tried to make this article as beginner-level as it could be, there are still some requirements;

YAML (basics)
Docker (basics)
Linux
Basics of VirtualBox

So what's the point of this article? What do we want to use Ansible and Vagrant for?

We would use Vagrant to create three remote Virtual Machines using Virtual Box and automate tasks using Ansible on the VMs.

The three VMs are;

The Controller VM: This controls other targets VMs and automates tasks using Ansible, so, Ansible will be installed on the Controller VM.
Target 1 and Target 2 VMs: These are the target VMs; we'd use the Controller VM to automate tasks in these target VMS.

Now, let's dive right in and install Vagrant.

Install Vagrant on your PC

Visit https://www.vagrantup.com/downloads and download; you can use the executable file for Windows OR use brew for Mac; it's available for Mac, Linux and Windows.

After downloading and installing it, to confirm, run;



vagrant --version

Also, install VirtualBox, https://www.virtualbox.org/wiki/Downloads.

Using Vagrant to create the VMs (Controller VMs and Targets)

As a Dockerfile is to Docker, a Vagrantfile is for Vagrant; inside a Vagrantfile is where we configure the VM we want to use, so open your text editor and create a Vagrantfile

Vagrantfile



NUM_NODES = 2
NUM_CONTROLLER_NODE = 1
IP_NTW = "192.168.56."
CONTROLLER_IP_START = 2
NODE_IP_START = 3

We created a few variables quick explanation about them.

NUM_NODES: This is the number of nodes(target VMs) we want to create.
NUM_CONTROLLER_NODE: Number of Controller nodes.
IP_NTW: This is the network range we want the VMs to belong to, so our network will have the format of 192.168.56.{any_number}
CONTROLLER_IP_START: We specified the start number where the controller would be assigned to in the network, so our controller will start from 192.168.56.2, and the NODE_IP_START will be starting from 3, that's 192.168.56.3.

These will all make sense in some moments. Let's continue for now. We'd be using an Ubuntu image, it's called Image in Docker, but it's called a Box in Vagrant; you can search for boxes at https://app.vagrantup.com/boxes/search.

Vagrantfile



NUM_NODES = 2
NUM_CONTROLLER_NODE = 1
IP_NTW = "192.168.56."
CONTROLLER_IP_START = 2
NODE_IP_START = 3

Vagrant.configure("2") do |config|
    config.vm.box = "ubuntu/trusty64"

end

The 2 in vagrant.configure("2") specifies the configuration version, don't change it, we also used the ubuntu/trusty64 box, the config is a local variable inside the vagrant.configure("2") directive, we use it to configure the box, like config.vm.box = "ubuntu/trusty64", this specifies the box we used.

Configuration for the Target VMs

Vagrantfile



NUM_NODES = 2
NUM_CONTROLLER_NODE = 1
IP_NTW = "192.168.56."
CONTROLLER_IP_START = 2
NODE_IP_START = 3

Vagrant.configure("2") do |config|
    config.vm.box = "ubuntu/trusty64"

    (1..NUM_NODES).each do |i|
        config.vm.define "target0#{i}" do |node|
            node.vm.provider "virtualbox" do |vb|
                vb.name = "target0#{i}"
                vb.memory = 2048
                vb.cpus = 2
            end

            node.vm.hostname = "target0#{i}"
            node.vm.network "private_network", ip: IP_NTW + "#{NODE_IP_START + i}"
            node.vm.network "forwarded_port", guest: 22, host: "#{2720 + i}"
        end
end

We created the target VMs, and we already created a Variable called NUM_NODES, so we created a foreach loop to loop from 1..NUM_NODES, and for each loop instance, we define the config for each target. Our counter variable is i.

Then we defined the name of the box config.vm.define "target0#{i}" do |node|, in it, we set a provider of Virtualbox, Vagrant will use Virtualbox to set up the box, also expect our configs to be for Virtualbox, we then gave the box a name, set the memory to use, also the number of CPUs.

node.vm.hostname = "target0#{i}" set the hostname, so the first target will be target01 and the second target02.

Next, we defined the networks.

A quick network refresher.

By default, all boxes in Vagrant use Adapter 1, which is the NAT; using NAT, our VMs can get their internet connections from the host(YOUR PC), but your VMs can't communicate with each other.
In Vagrant, a private network is the same as a Host-Only network; a Host-Only network allows VMs on the same network to communicate with each other but can't communicate outside the network.

So combining NAT and a Host-Only network means our VMs can communicate with each other (since they're on the same network); also, they can get Internet Connectivity from the host using the NAT.

Back to Vagrant, This line creates a private network(Host Only) node.vm.network "private_network", ip: IP_NTW + "#{NODE_IP_START + i}", also set the IP, it uses the IP_NTW and adds the NODE_IP_START variable and the current loop, poor little i, we could have used the DHCP server to automatically assign IP address to our VMs, but we won't be covering that.

node.vm.network "forwarded_port", guest: 22, host: "#{2720 + i}" this part defines a port forwarding, which is used to handle SSH connection; SSH connection uses the port 22 on all systems, so whenever the host receives a request on port 2720, it's routed to the VM on port 22(SSH), that's basically what port forwarding does, it forwards ports on the host to the VM in this case, using this you can SSH from your PC into the VMs.

Configuration for the Controller VM(s)

Vagrantfile



NUM_NODES = 2
NUM_CONTROLLER_NODE = 1
IP_NTW = "192.168.56."
CONTROLLER_IP_START = 2
NODE_IP_START = 3

Vagrant.configure("2") do |config|
    config.vm.box = "ubuntu/trusty64"

    (1..NUM_NODES).each do |i|
        config.vm.define "target0#{i}" do |node|
            node.vm.provider "virtualbox" do |vb|
                vb.name = "target0#{i}"
                vb.memory = 2048
                vb.cpus = 2
            end

            node.vm.hostname = "target0#{i}"
            node.vm.network "private_network", ip: IP_NTW + "#{NODE_IP_START + i}"
            node.vm.network "forwarded_port", guest: 22, host: "#{2720 + i}"
        end
    end

    i = 0

    (1..NUM_CONTROLLER_NODE).each do [i] 
        config.vm.define "nodecontroller" do |node|
            node.vm.provider "virtualbox" do |vb|
                vb.name = "nodecontroller"
                vb.memory = 2048
                vb.cpus = 2
            end

            node.vm.hostname = "nodecontroller"
            node.vm.network "private_network", ip: IP_NTW + "#{CONTROLLER_IP_START + i}"
            node.vm.network "forwarded_port", guest: 22, host: "#{2710 + i}"
        end
    end
end

Starting from the comment Configuration for Controller VM(s) down is where we did the config of the controller VM; there is nothing to explain here; both configs are similar. Your Vagrantfile should be the same as this.

Now let's run the Vagrantfile and set up the virtual machines, change the directory into where the Vagrantfile is then run.



vagrant up

This would take a few minutes, so be patient; when it finishes, you can run vagrant status to see the Virtual machines that were created.

You can also open your Virtualbox, and you would see the virtual machines there too.

Working with the Virtual Machines

Let's SSH into the nodecontroller.



vagrant ssh nodecontroller

If it requests a password, use vagrant as the password for all the VMS.

Get the IP address of `nodecontroller.`



ifconfig

You should see (192.168.56.2)

Now exit nodecontroller.



exit

Let's get the IP addresses of target01 and target02



vagrant ssh target01

Run ifconfig and exit, then repeat the same process for target02.

My IP addresses are;

target01: 192.168.56.4
target02: 192.168.56.5
nodecontroller: 192.168.56.2

Yours could be different; you can notice they all end in 56. this means they're on the same network and can communicate.

SSH to target02 from target01

First, SSH into target01.



ssh 192.168.56.5

Try SSH all vice and versa, from target01-target02, target02-target01, nodecontroller-target01, nodecontroller-target02.

Remember I said earlier that since we used a Host-Only network, we can communicate with other VMs on the same networks; let's try to SSH into target01 from nodecontroller.

You can also test internet connectivity on all VMs; let's try pinging google.com.



ping google.com

Now everything is set!

However, installing Ansible and Automating Tasks would come in the Part 2 series of this article. This one is long enough, felt like I've been typing forever, lol.

I know I said a lot in this article, I just wanted everyone to be able to follow along, including beginners, so I tried breaking everything down; hopefully, I didn't bore you.

If you got this far, Add a Reaction and Follow me so you will get notified when I post part 2 of this article.

Thanks for reading. 😀

Pipeline 101 for PHP and Laravel Projects with Jenkins and Docker

Kehinde Alade — Mon, 10 Oct 2022 13:56:51 +0000

Few months ago, I was trying to setup a pipeline for a Laravel project that I was working on, but I encountered some issues, I wasn't able to get an article that explains the process to a beginner, the Whys and Hows you know, but I was able to get it done.

In this article, I would explain the process like one would do to a beginner.

Setting up a Pipeline for a PHP or a Laravel project is easier than you might think, the prerequisite for this article are;

Docker (Install docker on your computer, we'd be using a Jenkins image and setting up Laravel and PHP in the container).
Jenkins (Don't install yet, we would be doing this later in the article).
Basic understanding of Docker and Jenkins generally.

Now, let's get our hands dirty!

First of all, we need to find a suitable Jenkins image that we can use, visit hub.docker.com and search for Jenkins.

We would be using that one above, just get the tag you need, let's follow the steps below.

1. Build our Jenkins Docker Container
We need to Setup Jenkins on Docker and Install PHP and Laravel.

Open your text editor and Create a Dockerfile.



FROM jenkins/jenkins:centos7

USER root

We used the jenkins/jenkins:centos7, this image is using cent-os based on RHEL (Red Hat Enterprise Linux), you can decide to use image tag you prefer.

You can go ahead and build the image for now using docker image build -t jenkins-laravel .

The command builds the Dockerfile in your current directory (.) then tag the image as jenkins-laravel.

2. Setup PHP and Remi Repository in the Dockerfile



FROM jenkins/jenkins:centos7

USER root

RUN yum -y install epel-release
RUN rpm -Uvh http://rpms.famillecollet.com/enterprise/remi-release-7.rpm
RUN yum-config-manager --enable remi-php74
RUN yum install php php-mbstring php-xml php-pdo php-pdo_mysql php-xdebug -y
RUN yum update -y

We added few lines to the Dockerfile, what the lines do is to setup the Remi RPM repository on cent-os, this allow us to be able to install PHP, and then install PHP on it.

So far we have setup Jenkins and PHP on the same image, this means we can run PHP commands right from Jenkins Pipeline Console, but PHP is not enough, we need to install Composer too.

3. Setting up Composer in the Dockerfile



FROM jenkins/jenkins:centos7

USER root

RUN yum -y install epel-release
RUN rpm -Uvh http://rpms.famillecollet.com/enterprise/remi-release-7.rpm
RUN yum-config-manager --enable remi-php74
RUN yum install php php-mbstring php-xml php-pdo php-pdo_mysql php-xdebug -y
RUN yum update -y
RUN cd /tmp
RUN curl -sS https://getcomposer.org/installer | php
RUN mv composer.phar /usr/local/bin/composer

The last few lines installs Composer, curl downloads the composer file and pipes it to PHP CLI., then the last line, we moved the actual downloaded composer file, composer.phar to /usr/local/bin/composer, this makes composer to be able to run with just typing composer in the terminal.

Everything is setup now, run docker image build -t jenkins-laravel ., we can now run PHP and composer commands right inside Jenkins Pipeline Console and this is all we need to setup Laravel.

It might take a while to get those images, just be patient, when it finishes, continue the article.

Now let us the launch our Container from the terminal with the new image we created.



docker run -d -p 4000:8080 --name jenkins jenkins-laravel

This runs our created Jenkins Image tagged jenkins-laravel in a detached mode and mapped the port 4000 on your host machine to the Container's port 8080.

After running this command, you would see an output of strings, that is the container ID, this means our container is now running in detached mode.

To access it, open your browser and visit http://localhost:4000, where 4000 is the port you mapped to your container.

You should see this screen if all went well.

Getting the Password for Jenkins

Run docker exec jenkins cat /var/jenkins_home/secrets/initialAdminPassword, copy the output and paste it in the password section on your Jenkins, then install suggested plugins.

If you can see this then you are good to go.

Let's create a Pipeline

Click on New Item on the Sidebar, give the Item a name and select Pipeline then click on OK.

Give it a description, just anything is OK for now.

Scroll down to the Pipeline section and make sure Pipeline Script is selected.

Paste these codes in there.



pipeline {
    agent any

    stages {
        stage('Build') {
            steps {
                git 'https://github.com/Kennibravo/jenkins-laravel.git'
                sh 'composer install'
                sh 'cp .env.example .env'
                sh 'php artisan key:generate'
            }
        }
        stage('Test') {
            steps {
                sh './vendor/bin/phpunit'
            }
        }
    }
}

Quick explanation on what the codes actually does



    stages {
        stage('Build') {
            steps {
                git 'https://github.com/Kennibravo/jenkins-laravel.git'
                sh 'composer install'
                sh 'cp .env.example .env'
                sh 'php artisan key:generate'
            }
        }
        stage('Test') {
            steps {
                sh './vendor/bin/phpunit'
            }
        }
    }

The laravel project is just basic laravel boilerplate codes, nothing else.

Stages: We defined all steps needed in our Pipeline here.
Stage: You can notice that we have two stage (Build and Test) inside the stages{} braces, in the Build stage, we cloned the https://github.com/Kennibravo/jenkins-laravel.git github repo, then run composer install and do other necessary things.

Don't forget we already installed Composer and Jenkins in the same container, so Jenkins can use the composer command.

After this, click on Save.

It takes you here.

We've created our Pipeline, now we need to launch it, to launch it, click on Build Now in the sidebar, then the Pipeline starts.

To see what's going on, click on that #1, then Console Output.

If your Pipeline was successful, you should see this.

You can see the two stages we created, Build and Test, if the pipeline fails, try checking the Console Output to see what's wrong.

Note that there are more to creating CI/CD pipelines to this, this article just covered the basics for you.

This brings us to the end of this article, if you enjoyed, you can add a Reaction or drop a comment if you had any issues or questions.

Thanks for reading. 😃

A Beginner Guide on How to Use the Vim Editor on Linux or Mac

Kehinde Alade — Fri, 07 Oct 2022 14:43:49 +0000

OK, a quick Vi story.

It's 1am in the morning in the year 2060, you could faintly hear the sound of a mechanical engine whirring, struggling to understand the situation, you opened your eyes and found yourself in a spaceship making a free fall towards the earth, while panicking you began to find the controls, fortunately you saw one, but it's a ugly black screen, on it is a white cursor blinking as if it were laughing at you cos you're in real mess, the spaceship is about to crash and you can't control it, the only thing you know about Vi are the memes you've once laughed at, hahaha.

Uhm, so back to business, Vi has two/three modes namely;

Command Mode
Insert Mode
Last line Mode

Note: Any command or explanation here will also work for VIM, which is an improved version of Vi.

This is only a beginner guide so I won't be wasting your time with lot of stories, well, except that boring Vi story you read.

Command Mode:
This is often the most confused mode in Vi, you remember that time you mistakenly opened your Vi editor, then you start hitting all the keys on your keyboard, you were in the command mode, the command mode is the default mode in Vi, open up your terminal or CLI app then copy and paste this;

echo "Here is the first file in VIM" >> firstText.txt

The above line just output the content "Here is the first file in VIM" into the firstText.txt file.

Now let's open up the file using Vi.

vi firstText.txt

And then boom that ugly and unattractive screen spuns up and it looks like this, mine is light, yours could be dark;

As at this instance, we're currently in the Command Mode because it is the default mode, in command mode, as opposed to normal text editors, you can't type or insert text in your file, you can only issue commands like Undo, Redo, Quit, Save, etc.

You can move around in the command mode using your arrow keys.

Let's try out some commands in the command mode!

Delete character: x

Press x, this deletes the current character you're on and it looks like this;

Keep on pressing x until it deletes all characters and looks like this.

Let's try to undo the characters we deleted.

Undo: u

Keep pressing u till all the text appears.

Instead of pressing x multiple time, you can just;

Delete whole line: dd

Press dd and it deletes the whole current line and looks like;

You can Undo the changes so all the text appears back.

There are also other commands like;

Copy: yy
Paste: p

Commands aside, let's continue to the other mode, we'd be seeing lot of commands, continue reading.

So far, we've played around in the command mode, but never for once did we actually insert data, uhm, can we not insert data like we will in a GUI text editor?

Yeah, you guessed right!

We can't!

Sorry, I mean we can, just kidding.

Insert Mode:
In this mode, you can insert data as you would in a GUI text editor, but how do we get to this mode? I mean we can't insert data in Command mode.

From command mode, there are lot of ways we can goto the Insert mode, one is pressing i on your PC.

We're currently in the command mode in the image above, you can try type stuffs here but it won't go through until you goto Insert mode, so press i (small letter 'i') to switch to Insert mode;

Bottom left in the terminal, you can notice a *-- INSERT -- *, this means we're currently in the Insert mode and can now start typing.

In Insert mode, you can type as you would type in a normal text editor.

Your backspace key would work, even Ctrl + C to Copy and Ctrl + V for Paste even the Enter key and others would work, so you can play around in here.

Let's try adding more data into the file and save it, erase all data in the file and type;

This is to test out the Insert Mode

Note: Type it yourself, don't copy it from here.

Let's try to save the file and exit Vi.

We need to go back to the Command Mode in order to save this file and exit the editor, since we can switch to Insert Mode from Command Mode by pressing i, how do we go back to the Command mode?

Very easy! just hit your ESC key(while in insert mode) on your PC.

Now we're back to the Command Mode.

Save: :w
Quit: :q
Save and Quit Vi: :wq
Quit without saving: :q!

Let's try to Save and Quit Vi, press :wq

Note:: Whenever you press : while in Command Mode, it takes you to the Last Line Mode

After you've typed in :wq, hit the Enter key.

And boom! We're Saved and exited Vi.

Let's verify the changes we made to the firstText.txt in our terminal.

cat firstText.txt

Here is the output, cat is used to output the content of a file.

We can also use Vi to create a file and edit it immediately.

vi secondText.txt

This creates the secondText.txt file and open with Vi.

This is the only basics you have to know to start using Vi, I attached a cheatsheet to this article so you can get more shortcuts from it.

Here is a link to a Cheatsheet: https://cheatography.com/ericg/cheat-sheets/vi-editor/pdf/

Now that you can use Vi, you can go on and brag to your friends and even pick up girls with it, I mean who doesn't love someone who can use Vi.

Takeaways from this article.

Command Mode is the default mode for Vi
Use i to switch to Insert Mode from Command Mode
Use ESC key to switch back to Command Mode from Insert Mode
Typing : in the command mode takes you to the Last Line Mode, you can then Save, Quit the file

So this brings us to the end of this article, I would making articles on Linux and DevOps generally, so keep close tab.

If you enjoyed the article, add a reaction for me. 😊

Keep Vi-ing high and Cheers!

DEV Community: Kehinde Alade

Ansible Tutorial: Automate and Configure Remote Linux Servers

Getting started with Ansible

Let's create an Inventory

Let's ping target01

Quick explanation

Introduction to Ansible Playbooks

Let's create an Ansible Playbook

Explanation

The first task explanation

The second task explanation

How to use SCP

Install SCP Plugin in Vagrant

Format of the SCP command

What are Ansible Modules?

Install PHP/MYSQL and Apache on all VMs using Ansible Playbook

In playbook.plays.yaml

Quick explanation

How to Create and Automate Virtual Machines using Vagrant

Install Vagrant on your PC

Using Vagrant to create the VMs (Controller VMs and Targets)

Configuration for the Target VMs

Configuration for the Controller VM(s)

Vagrantfile

Working with the Virtual Machines

Get the IP address of nodecontroller.

Let's get the IP addresses of target01 and target02

SSH to target02 from target01

Pipeline 101 for PHP and Laravel Projects with Jenkins and Docker

Open your text editor and Create a Dockerfile.

Getting the Password for Jenkins

Let's create a Pipeline

Quick explanation on what the codes actually does

A Beginner Guide on How to Use the Vim Editor on Linux or Mac

Get the IP address of `nodecontroller.`