Stardom Solutions

Monday, 6 May 2024

Choosing Between AWS Load Balancers: ALB vs. NLB

📌 Choosing Between AWS Load Balancers: ALB vs. NLB – Features, Use Cases and Technical Considerations📌

Choosing between AWS Application Load Balancer (ALB) and Network Load Balancer (NLB) depends on the specific requirements of your application's architecture, traffic patterns, and the protocols used. Both types of load balancers serve to distribute traffic across multiple targets, but they operate at different layers of the OSI model and offer different features. Here's a detailed comparison and an explanation of how each works:

✅ AWS Application Load Balancer (ALB)
Layer 7 Load Balancing: ALB operates at the OSI model's application layer (Layer 7). It can make routing decisions based on the content of the HTTP/HTTPS headers, URL paths, query strings, and more.

Features:
✔️ Content-Based Routing: ALB allows you to route traffic based on request content, making it ideal for modern application architectures, including microservices and container-based applications.
✔️ Host and Path-Based Routing: You can route traffic based on the domain name (host) or the URL path specified in the request.
✔️ Support for HTTP/2 and WebSocket: It supports advanced web protocols, which are beneficial for improving performance and real-time communication.
✔️ Integration with AWS Services: ALB integrates well with other AWS services, such as ECS (Elastic Container Service), EKS (Elastic Kubernetes Service), and AWS WAF (Web Application Firewall).

✅ AWS Network Load Balancer (NLB)
Layer 4 Load Balancing: NLB operates at the transport layer (Layer 4). It routes traffic based on IP protocol data, such as TCP port and IP address.

Features:
✔️ High Performance and Low Latency: NLB is optimized to handle millions of requests per second while maintaining low latencies.
✔️ Static IP or Elastic IP: Unlike ALB, NLB allows the assignment of a static IP per Availability Zone or the use of Elastic IP addresses.
✔️ Direct TCP and UDP Traffic Routing: Supports routing of TCP and UDP traffic, making it suitable for applications that require direct connection to the load balancer.

Choosing Between ALB and NLB
✔️ Protocol and Routing Requirements: If your application requires complex routing based on the content of the HTTP/HTTPS headers or needs WebSocket support, choose ALB. If your application primarily uses TCP or UDP and benefits from low latency and high throughput, go with NLB.
✔️ Performance Considerations: For ultra-high performance and low latency requirements, NLB is typically more suitable because of its ability to handle volatile high traffic patterns and its operational efficiency at the TCP level.
✔️ IP Address Needs: If having a static IP is crucial for your application deployment, NLB would be the better choice.
✔️ Integration and Features: Consider the additional features like WAF integration or the need for detailed routing rules, which might lean towards choosing ALB.

Friday, 18 February 2022

SonarQube installation on Ubuntu 20.04

1) Update System

sudo apt-get update && sudo apt-get upgrade -y

2) Install open-jdk

sudo apt-get install openjdk-11-jdk -y

3) Download the SonarQube software.

cd /opt
sudo wget https://binaries.sonarsource.com/Distribution/sonarqube/sonarqube-7.6.zip

4) Extract SonarQube software

sudo unzip sonarqube-7.6.zip
sudo mv sonarqube-7.6 sonarqube

5) Please change permissions ( Update user as per requirement )

cd /opt/

sudo chown -R vagrant:vagrant sonarqube

6) Start Sonar

cd /opt/sonarqube/bin/linux-x86-64
./sonar.sh start

You should able to access SonarQube over 9000 port now. By default admin/admin will be credentials for SonarQube.

If you are using VM or Vagrant please enable port forwarding.

7) Enable Sonar as service on Ubuntu
Create sonar service file
sudo vi /etc/systemd/system/sonarqube.service

Add below content to above file. If you want to change user to run sonarqube process please update User and Group.

[Unit]
Description=SonarQube service
After=syslog.target network.target

[Service]
Type=simple
User=vagrant
Group=vagrant
PermissionsStartOnly=true
ExecStart=/bin/nohup java -Xms32m -Xmx32m -Djava.net.preferIPv4Stack=true -jar /opt/sonarqube/lib/sonar-application-7.6.jar
StandardOutput=syslog
LimitNOFILE=65536
LimitNPROC=8192
TimeoutStartSec=5
Restart=always

[Install]
WantedBy=multi-user.target

8) Start and Enable Sonar Service
sudo systemctl start sonarqube
sudo systemctl enable sonarqube

9) Check SonarQube status to ensure it is working as expected.
sudo systemctl status sonarqube

Jenkins installation on Ubuntu 20.04

1) Update System

sudo apt-get update && sudo apt-get upgrade -y

2) Install open-jdk

sudo apt-get install openjdk-11-jdk -y

3) Add Jenkins key.

wget -q -O - https://pkg.jenkins.io/debian-stable/jenkins.io.key | sudo apt-key add -

4) Configure Jenkins repo.
sudo sh -c 'echo deb http://pkg.jenkins.io/debian-stable binary/ > /etc/apt/sources.list.d/jenkins.list'

5) Update system

sudo apt-get update

6) Install Jenkins.

sudo apt-get install jenkins -y

6) Once Installation of Jenkins is completed start jenkins service.
sudo systemctl start jenkins

7) Enable Jenkins service to be restart on system reboot
sudo systemctl enable jenkins

8) By Default Jenkins will run and accessible over 8080 port. We need to open port to access in our browser if we are using Jenkins on Virtual Environment.

i) If you are using Vagrant please add below line to Vagrantfile and restart vm.
config.vm.network "forwarded_port", guest: 8080, host: 8080

ii) If you are using Oracle VirtualBox please follow below steps to open 8080 port

Right Click on VM and go to settings.

Click On Network and expand advanced button.

Click on Port Forwarding button and add a new port mapping as mentioned in below screen.

9) Once you finished above step you should able to access Jenkins on your favorite browser.

10) You need to copy the password from /var/lib/jenkins/secrets/initialAdminPassword to text box and click on continue.

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

11) Click on Suggested Plugin Installation. This will install all required plugins to start with CI & CD pipeline.

Apache Tomcat 9 Installation on Ubuntu 20.04

1) Update System

sudo apt-get update && sudo apt-get upgrade -y

2) Install open-jdk

sudo apt-get install openjdk-11-jdk -y

3) Download Apache Tomcat and extract tomcat to your Linux Machine

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

# Update vagrant user as per your requirement

sudo chown -R vagrant:vagrant tomcat

4) Configure Apache Tomcat 9 as system service.

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

Add below content.

[Unit]

Description=Tomcat 9

After=network.target

[Service]

Type=forking

# Update users as per target machine

User=vagrant

Group=vagrant

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

5) Check tomcat service

sudo systemctl status tomcat

6) Enable tomcat service

sudo systemctl enable tomcat

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

Pages

Monday, 6 May 2024

Friday, 18 February 2022

Monday, 20 December 2021

Saturday, 9 October 2021

Tuesday, 5 October 2021

Environment and Prerequisite

Host Key Checking

Disable Host Key Checking When Using SSH

1. Disable when using ssh command

2. Edit ssh config file

Sunday, 3 October 2021

git init

git init