Stardom Solutions: 2021

Monday 20 December 2021

Jenkins cannot delete root-owned files/folders in jenkins-owned directories

In this post we will discuss abut most frequent issues faced in Jenkins build.

When you try to use docker image to run your jobs you may end up in creating some file which are created by root user ( from Docker image ). In this case from next build onwards we will see some issues to clean old workspace. Even if you try to use cleanUP workspace plugin you will end up with permission issues.

To avoid this issue please follow below steps
1) Install acl package based on your distribution.

Debian

apt-get install acl

Ubuntu

apt-get install acl

Alpine

apk add acl

Arch Linux

pacman -S acl

Kali Linux

apt-get install acl

CentOS

yum install acl

Fedora

dnf install acl

2) Follow below steps to clean workspace and apply acl on workspace folder. After this change you will see any file or folder which is created in workspace folder will have complete ownership of jenkins user.

$ rm -rf workspace # to avoid any inconsistencies in existing files
$ mkdir workspace
$ sudo setfacl -dm 'u:<your_jenkins_user_name>:rwx' workspace

Saturday 9 October 2021

Linux Technical Interview Questions

In some questions I am encouraging to search online because it will help you practice for

searching more complicated questions in the future

(Good Luck)

1. When you login you get “$” prompt, what is the prompt for root?

2. Explain the difference between grep and egrep?

Search online

3. What is the port # for DNS, NTP and NFS?

53,123 and 111/2049

4. What is the configuration file name of DNS and where is it

located?

/etc/named.conf

5. How many new directories will be created after running the

following command

mkdir {a..c}{1..3}

6. Your PC is configured with a DNS server address but not the

default gateway. Can the PC access internet?

7. What is the difference between IP and Gateway?

Search online

8. Can you assign one static IP to 2 computers, if not then why?

No because it will create IP conflict

9. How to change IPs address to static?

ifconfig x.x.x.x

10. You are trying to ping a server by hostname and you get an error

message, “ping: unknown host …”. What could be the reason and

how to solve the problem so you can ping it by hostname?

Check for /etc/hosts or DNS to see if it has hostname to IP entry

11. Explain the difference between relative and absolute path?

Absolute path starts from / where relative path is your current

Tuesday 5 October 2021

Disable host key checking while connecting ssh in Linux

Environment and Prerequisite

Linux
SSH(OpenSSH)

Host Key Checking

When we connect to remote server by using ssh, client compares client’s saved key and remote server’s key to authenticate server.
This process prevents from Man-in-the-middle attack.

Disable Host Key Checking When Using SSH

Remote host’s key will be added if there is no added key in ~/.ssh/known_hosts.
Connect to remote server even though saved key is different from server’s key.

1. Disable when using ssh command

Use StrictHostKeyChecking=no option.

ssh -o StrictHostKeyChecking=no [DOMAIN_OR_IP]

2. Edit ssh config file

~/.ssh/config

Add option to specific host like below.

Host twpower-private-server
    HostName [IP ADDRESS]
    StrictHostKeyChecking no
    Port 22
    User [USERNAME]
    IdentityFile [IDENTITY KEY FILE]

/etc/ssh/ssh_config

There is * in config file. So this disables host key checking to all hosts.
/etc/ssh/ssh_config defines all the default settings for the client utilities for all users on that system.

Host *
    StrictHostKeyChecking no

Sunday 3 October 2021

Git Basic Tutorial

git init

The git init command is the first command that you will run on Git. The git init command is used to create a new blank repository. It is used to make an existing project as a Git project. Several Git commands run inside the repository, but init command can be run outside of the repository.

The git init command creates a .git subdirectory in the current working directory. This newly created subdirectory contains all of the necessary metadata. These metadata can be categorized into objects, refs, and temp files. It also initializes a HEAD pointer for the master branch of the repository.

Command: git init

git add

The git add command is used to add file contents to the Index (Staging Area).This command updates the current content of the working tree to the staging area. It also prepares the staged content for the next commit. Every time we add or update any file in our project, it is required to forward updates to the staging area.

The git add command is a core part of Git technology. It typically adds one file at a time, but there some options are available that can add more than one file at once.

The "index" contains a snapshot of the working tree data. This snapshot will be forwarded for the next commit.

The git add command can be run many times before making a commit. These all add operations can be put under one commit. The add command adds the files that are specified on command line.

The git add command does not add the .gitignore file by default. In fact, we can ignore the files by this command.

Command: git add $(filename)

git commit

It is used to record the changes in the repository. It is the next command after the git add. Every commit contains the index data and the commit message. Every commit forms a parent-child relationship. When we add a file in Git, it will take place in the staging area. A commit command is used to fetch updates from the staging area to the repository.

The staging and committing are co-related to each other. Staging allows us to continue in making changes to the repository, and when we want to share these changes to the version control system, committing allows us to record these changes.

Commits are the snapshots of the project. Every commit is recorded in the master branch of the repository. We can recall the commits or revert it to the older version. Two different commits will never overwrite because each commit has its own commit-id. This commit-id is a cryptographic number created by SHA (Secure Hash Algorithm) algorithm.

Command: git commit

git clone

In Git, cloning is the act of making a copy of any target repository. The target repository can be remote or local. You can clone your repository from the remote repository to create a local copy on your system.

The git clone is a command-line utility which is used to make a local copy of a remote repository. It accesses the repository through a remote URL.

Command: git clone $(repository link)

git stash

Sometimes we want to switch the branches, but we are working on an incomplete part of your current project. we don't want to make a commit of half-done work. Git stashing allows us to do so. The git stash command enables you to switch branches without committing the current branch.

Generally, the stash's meaning is "store something safely in a hidden place." The sense in Git is also the same for stash; Git temporarily saves your data safely without committing.

Stashing takes the messy state of your working directory, and temporarily save it for further use.

Command: git stash

git ignore

In Git, the term "ignore" is used to specify intentionally untracked files that Git should ignore. It doesn't affect the Files that already tracked by Git.

Generally, the Ignored files are artifacts and machine-generated files. These files can be derived from your repository source or should otherwise not be committed.

Git ignore files is a file that can be any file or a folder that contains all the files that we want to ignore. The developers ignore files that are not necessary to execute the project. Git itself creates many system-generated ignored files. Usually, these files are hidden files. There are several ways to specify the ignore files. The ignored files can be tracked on a .gitignore file that is placed on the root folder of the repository. No explicit command is used to ignore the file.

There is no explicit git ignore command; instead, the .gitignore file must be edited and committed by hand when you have new files that you wish to ignore. The .gitignore files hold patterns that are matched against file names in your repository to determine whether or not they should be ignored.

There is no command in Git to ignore files; alternatively, there are several ways to specify the ignore files in git. One of the most common ways is the .gitignore file.

Steps to create .gitignore file in linux Step – 1

cat > .gitignore

*.txt

/newfolder/* Step – 2 Press Clt + D Step – 3

git add .gitignore

git commit -m "ignored directory created."

git origin master

The term "git origin master" is used in the context of a remote repository. It is used to deal with the remote repository. The term origin comes from where repository original situated and master stands for the main branch.

Master is a naming convention for Git branch. It's a default branch of Git. After cloning a project from a remote server, the resulting local repository contains only a single local branch. This branch is called a "master" branch. It means that "master" is a repository's "default" branch.

In most cases, the master is referred to as the main branch. Master branch is considered as the final view of the repo. Your local repository has its master branch that always up to date with the master of a remote repository.

In Git, The term origin is referred to the remote repository where you want to publish your commits. The default remote repository is called origin, although you can work with several remotes having a different name at the same time. It is said as an alias of the system.

The origin is a short name for the remote repository that a project was initially being cloned. It is used in place of the original repository URL. Thus, it makes referencing much easier.

Origin is just a standard convention. Although it is significant to leave this convention untouched, you could ideally rename it without losing any functionality.

Commands:

git pull origin master (is used to push the changes to the remote repository) git push origin master (is used to access the repository from remote to local)

git remote

In Git, the term remote is concerned with the remote repository. It is a shared repository that all team members use to exchange their changes. A remote repository is stored on a code hosting service like an internal server, GitHub, Subversion, and more. In the case of a local repository, a remote typically does not provide a file tree of the project's current state; as an alternative, it only consists of the .git versioning data.

To check the configuration of the remote server, run the git remote command. The git remote command allows accessing the connection between remote and local.

Command: git remote (want to see the original existence of your cloned repository)

git checkout

In Git, the term checkout is used for the act of switching between different versions of a target entity. The git checkout command is used to switch between branches in a repository.

The git checkout command operates upon three different entities which are files, commits, and branches. Sometimes this command can be dangerous because there is no undo option available on this command.

It checks the branches and updates the files in the working directory to match the version already available in that branch, and it forwards the updates to Git to save all new commit in that branch.

Command: git checkout $(branch_name)

git pull

The term pull is used to receive data from GitHub. It fetches and merges changes from the remote server to your working directory. The git pull command is used to pull a repository.

Pull request is a process for a developer to notify team members that they have completed a feature. Once their feature branch is ready, the developer files a pull request via their remote server account. Pull request announces all the team members that they need to review the code and merge it into the master branch.

The pull command is used to access the changes (commits)from a remote repository to the local repository. It updates the local branches with the remote-tracking branches. Remote tracking branches are branches that have been set up to push and pull from the remote repository. Generally, it is a collection of the fetch and merges command. First, it fetches the changes from remote and combined them with the local repository.

Command: git pull (repository link)

git push

The push term refers to upload local repository content to a remote repository. Pushing is an act of transfer commits from your local repository to a remote repository. Pushing is capable of overwriting changes; caution should be taken when pushing.

Moreover, we can say the push updates the remote refs with local refs. Every time you push into the repository, it is updated with some interesting changes that you made. If we do not specify the location of a repository, then it will push to default location at origin master.

The "git push" command is used to push into the repository. The push command can be considered as a tool to transfer commits between local and remote repositories.

Git push origin master is a special command-line utility that specifies the remote branch and directory. When you have multiple branches and directory, then this command assists you in determining your main branch and repository.

Generally, the term origin stands for the remote repository, and master is considered as the main branch. So, the entire statement "git push origin master" pushed the local content on the master branch of the remote location.

Command: git push origin master

Monday 30 August 2021

Azure CLI commands

Get what version of the CLI you have

az --version

Get help

az help

Logging to Azure portal

az login

az login -u myemail@address.com

List accounts

az account list

Set subscription

az account set --subscription "xxx"

Listing locations and resources / general

List all locations

az account list-locations

List all my resource groups

az resource list

Creating a basic VM / Resource Group / Storage Account

Get all available VM sizes

az vm list-sizes --location eastus

Get all available VM images for Windows and Linux

az vm image list --output table

Create a Resource group

az group create --name demo-rg --location eastus2

Create a Linux VM

az vm create --resource-group demo-rg --name myvmfordemo --image ubuntults --admin-username adminazure

Create a Windows VM

az vm create --resource-group demo-rg --name mywindowsvmfordemo --image win2016datacenter --admin-username adminazure

Create a Storage account.

az storage account create -g demo-rg -n mystorageaccount -l eastus2 --sku Standard_LRS

DELETING A RESOURCE GROUP

Permanetly deletes a resource group

az group delete --name demo-rg

Managing VM's

List your VMs

az vm list

Start a VM

az vm start --resource-group myResourceGroup --name myVM

Stop a VM

az vm stop --resource-group myResourceGroup --name myVM

Deallocate a VM

az vm deallocate --resource-group myResourceGroup --name myVM

Restart a VM

az vm restart --resource-group myResourceGroup --name myVM

Redeploy a VM

az vm redeploy --resource-group myResourceGroup --name myVM

Delete a VM

az vm delete --resource-group myResourceGroup --name myVM

Create image of a VM

az image create --resource-group myResourceGroup --source myVM --name myImage

Create VM from image

az vm create --resource-group myResourceGroup --name myNewVM --image myImage

List VM extensions

az vm extension list --resource-group azure-playground-resources --vm-name azure-playground-vm

Delete VM extensions

az vm extension delete --resource-group azure-playground-resources --vm-name azure-playground-vm --name bootstrapper

Sunday 1 August 2021

Apache Tomcat 9 Installation on Centos 8

Pre-Requirement:

Update repo details

sudo sed -i 's/mirrorlist/#mirrorlist/g' /etc/yum.repos.d/CentOS-*

sudo sed -i 's|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g' /etc/yum.repos.d/CentOS-*

Please Follow below instructions to install and configure Tomcat on CentOS 8 machine

1) Install epel-release.

sudo yum install epel-release -y

2) Install open-jdk

sudo yum install java-11-openjdk -y

3) Download Apache Tomcat

  cd /opt/        sudo wget https://archive.apache.org/dist/tomcat/tomcat-9/v9.0.50/bin/apache-tomcat-9.0.50.tar.gz
  sudo tar -zxvf apache-tomcat-9.0.50.tar.gz   sudo mv apache-tomcat-9.0.50 tomcat
  sudo chmod -R 777 tomcat
  sudo chown -R vagrant:vagrant tomcat

4) Configure Apache Tomcat 9 as system service.

Create tomcat service file and add below content.

sudo vi /etc/systemd/system/tomcat.service

[Unit]

Description=Tomcat 9

After=network.target

[Service]

Type=forking

User=vagrant

Group=vagrant

Environment="JAVA_HOME=/usr/lib/jvm/jre"

Environment="JAVA_OPTS=-Djava.security.egd=file:///dev/urandom"

Environment="CATALINA_BASE=/opt/tomcat"

Environment="CATALINA_HOME=/opt/tomcat"

Environment="CATALINA_PID=/opt/tomcat/temp/tomcat.pid"

ExecStart=/opt/tomcat/bin/startup.sh

ExecStop=/opt/tomcat/bin/shutdown.sh

[Install]

WantedBy=multi-user.target

5) Start tomcat service

sudo systemctl start tomcat

6) Enable tomcat service

sudo systemctl enable tomcat

Friday 23 July 2021

Docker installation on CentOS 8

CentOS 8 uses the YUM package manager version v4.0.4. This version now uses DNF (Dandified YUM).

1) Use DNF to add and enable the official Docker CE repository. Type the following command in your terminal window:

sudo dnf config-manager --add-repo=https://download.docker.com/linux/centos/docker-ce.repo

2) To list all the available docker-ce packages, type:

dnf list docker-ce --showduplicates | sort -r

3) Install docker now

sudo dnf install docker-ce -y

4) Enable docker service to be start during system boot up

sudo systemctl enable docker

5) Start docker service

sudo systemctl start docker

6) Add current user to Docker User Group - We may need to restart session again to run docker cli commands with current user

sudo usermod -aG docker $USER

7) We need to disable firewalld for DNS resolution inside Docker containers to work

sudo systemctl disable firewalld

8) Test Docker setup.

docker run hello-world

After running above command you should be able to see below output.

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/