DEV Community: Raza

Changing Jenkins Port on Linux: A Step-by-Step Guide

Raza — Thu, 23 Nov 2023 06:53:14 +0000

Introduction:

Jenkins, a widely-used automation server in software development, sometimes requires tweaking, such as changing its default port. In this guide, we'll walk through the process of changing the Jenkins port on a Linux system. No tech jargon, just straightforward steps to help you make this adjustment seamlessly.

Steps

Step 1: Stop the Jenkins and find the Jenkins Configuration File.
Locate the Jenkins file:

 sudo systemctl stop jenkins
 cd /etc/default/
 //Take a backup of the jenkins file.
 cp jenkins jenkins_backup
 sudo vim jenkins

Edit the file, find HTTP_PORT and modify it with your preferred port number. For instance:

 HTTP_PORT=8084

After altering the port and saving, start Jenkins:

 sudo systemctl start jenkins

Verify it by visiting http://your_jenkins_instance_ip:8084

Make sure jenkins is still not working on 8080 port or your previous port; incase it does , follow this

sudo vim /usr/lib/systemd/system/jenkins.service

Locate Environment="JENKINS_PORT=8080". Change the port number to new port number and save.

systemctl daemon-reload
systemctl restart jenkins.service

Keep in mind that adjusting the port could impact other services or tools relying on the standard Jenkins port (8080). Confirm that the new port is available and not in use by any other application on your system. Also, don't forget to modify firewall or security group settings if needed! 🚀

AWS Magic: Give Your Account a Cool Alias

Raza — Mon, 20 Nov 2023 14:11:49 +0000

Introduction:

Do you want to learn how to turn that boring AWS User Account ID into a cool alias to keep things simple and fun?

This step-by-step guide is your ticket to making AWS a bit more personal.

Step 1: Go to the AWS Management Console

Step 2: Check Out the IAM Dashboard

Once you're in, find and click on "Services" in the top left. In the "Security, Identity, & Compliance" part, click "IAM" or Search IAM on the search input.

Step 3: Find IAM Dashboard

On the IAM dashboard, your User Account ID is right there. click create alias.

Step 4: Type Preferred alias in the Popup input and click create alias.

Step 5: Check Out Your New Alias

Use the alias to log in. It will be useful, especially if you have multiple AWS accounts.

Conclusion:

Great! You've a AWS User Account ID with a personal touch. This simple trick adds personality to your AWS adventure. So go ahead and explore AWS with your spiffy new alias!

P.S.: Remember, nicknames should be unique and easiest, so choose wisely! 🚀✨

A Day in the Life of a DevOps Engineer

Raza — Sun, 19 Nov 2023 18:47:30 +0000

A Day in the Life of a DevOps Engineer

Hey folks! Let's have a little chat about what we do as a DevOps engineers. It's kind of like being the mastermind behind the scenes, making sure our software world ticks smoothly.

1. Infrastructure as Code (IaC):

So, first things first. Imagine we're building a digital town for our software. we use tools like:

Terraform
Ansible
CloudFormation

2. Continuous Integration/Continuous Deployment (CI/CD):

Next up, it's like being the conductor of an orchestra. We make sure our software plays its music without any hiccups. Tools like:

Jenkins
GitLab CI/CD
CircleCI help me keep everything in harmony.

3. Containerization and Orchestration:

We pack up our software into these neat little containers and use tools like:

Docker
Kubernetes to make sure these containers dance together without any missteps.

4. Cloud Services:

Taking our show to the clouds, we manage our digital stuff on platforms like:

AWS
Azure
GCP

5. Monitoring and Logging:

Always keeping an eye out, We set up tools to watch over our software's every move. Think:

Prometheus
Grafana
ELK Stack (Elasticsearch, Logstash, Kibana)

6. Security:

Safety first, right? We use tools like:

HashiCorp Vault
SonarQube
Twistlock to keep our digital town safe and sound.

7. Collaboration and Communication:

In our world, teamwork is the secret sauce. Tools like:

Slack
Jira
Confluence help us all work together seamlessly.

8. Automated Testing:

We bring in the tech magic to check if our software behaves. Tools like:

Selenium
JUnit
Cucumber automate these checks like a helping hand.

9. Release Management:

Planning the grand entrance of our software updates is crucial. Tools like:

GitFlow
SemVer
Jenkins Pipeline help us stage the perfect debut.

10. Configuration Management:

Making sure everything runs smoothly, no matter where it is. Tools like:

Ansible
Puppet
Chef make it happen.

11. Documentation:

We're the storytellers, creating guides so everyone gets our digital tale. Tools like:

Confluence
Markdown
Git help us spin the story.

12. Incident Response and Troubleshooting:

When things get tricky, we're the first responders, armed with tools like:

PagerDuty
New Relic
Datadog

13. Performance Optimization:

Finding and fixing what slows us down, using tools like:

Google PageSpeed Insights
Apache JMeter
Gatling

14. Continuous Learning:

Staying in the loop with the latest tech gossip by:

Reading tech blogs
Attending conferences
Taking online courses

15. Collaborative Tooling:

Tools like:

Slack
Jira
Confluence keep our team in sync.

So, as a DevOps engineer with over few years in the game, it's not just about the tech. It's about guiding the team, making smart decisions, and ensuring our software world runs like a well-oiled machine. Here's to keeping the digital magic alive! 🚀

A Quick Guide to Command Your Docker Containers

Raza — Sat, 18 Nov 2023 09:44:32 +0000

Basic Container Operations

Run a Container

docker run -it ubuntu

Starts a new interactive container using the Ubuntu image.

Build an Image

docker build -t my-custom-image:latest .

Creates a custom Docker image named 'my-custom-image' from the current directory.

Pull an Image

docker pull nginx:latest

Downloads the latest version of the Nginx image from the Docker Hub.

Push an Image

docker push my-custom-image:latest

Uploads the custom image 'my-custom-image' to a Docker registry.

List Images

docker images

Displays a list of locally available Docker images.

Container Lifecycle Management

Stop a Container

docker stop my_container

Gracefully stops the running container 'my_container'.

Start a Container

docker start my_container

Resumes execution of the stopped container 'my_container'.

Restart a Container

docker restart my_container

Stops and then starts the container 'my_container'.

Kill a Container

docker kill -s SIGTERM my_container

Sends a termination signal to forcefully stop the running container 'my_container'.

Remove a Container

docker rm my_container

Deletes the container 'my_container'.

Image Management

Remove an Image

docker rmi my-custom-image:latest

Deletes the image 'my-custom-image' with the latest tag.

Create Image from Changes

docker commit my_container my-custom-image:latest

Creates a new image 'my-custom-image' from changes made in a running container 'my_container'.

Save Images to Archive

docker save -o my-images.tar.gz my-custom-image:latest

Saves the image 'my-custom-image' with the latest tag to a tar archive.

Load Image from Archive

docker load -i my-images.tar.gz

Loads an image from the tar archive 'my-images.tar.gz'.

Container Interaction

Execute Command in Container

docker exec -it my_container bash

Runs an interactive bash shell in the running container 'my_container'.

Fetch Container Logs

docker logs my_container

Retrieves and displays the logs of the container 'my_container'.

Inspect Container or Image

docker inspect my_container

Retrieves detailed information about the container 'my_container'.

Copy Files Between Container and Host

docker cp my_container:/path/in/container /path/on/host

Copies files or folders between the container 'my_container' and the local filesystem.

System Cleanup and Maintenance

Remove Unused Resources

docker system prune

Cleans up stopped containers, dangling images, and unused networks and volumes.

Miscellaneous Commands

List Port Mappings

docker port my_container

Shows the port mappings of the container 'my_container'.

Display Running Processes

docker top my_container

Lists the running processes inside the container 'my_container'.

Manage Volumes

docker volume ls

Lists the Docker volumes on the host.

Show Docker Version

docker version

Displays information about the installed Docker version.

Show Changes in Container Filesystem

docker diff my_container

Shows the filesystem changes made in the container 'my_container'.

Export Container Filesystem

docker export my_container > my_container_exported.tar

Exports the filesystem of the container 'my_container' to a tar archive.

Import Filesystem to Create Image

docker import my_container_exported.tar my-imported-image:latest

Imports the filesystem from the tar archive 'my_container_exported.tar' to create a new image 'my-imported-image' with the latest tag.

Docker Network Commands

List Docker Networks

docker network ls

Displays a list of Docker networks.

Create a Docker Network

docker network create my_network

Creates a new Docker network named 'my_network'.

Inspect Docker Network

docker network inspect my_network

Retrieves detailed information about the Docker network 'my_network'.

Docker Registry Commands

Docker Login

docker login

Logs in to a Docker registry.

Docker Logout

docker logout

Logs out from a Docker registry.

Docker Volume Commands

Create a Docker Volume

docker volume create my_volume

Creates a new Docker volume named 'my_volume'.

Inspect Docker Volume

docker volume inspect my_volume

Retrieves detailed information about the Docker volume 'my_volume'.

Docker Compose Commands

Docker Compose Up

docker-compose up

Starts services defined in a docker-compose.yml file.

Docker Compose Down

docker-compose down

Stops and removes containers, networks, and volumes defined in a docker-compose.yml file.

Refactoring Javascript code with Object Literals: A Clean and Readable Approach

Raza — Tue, 04 Jul 2023 18:26:31 +0000

This is and slightly modified article i wrote few years back on medium.
link.

Introduction:

When it comes to user authentication or multiple payment types, we often encounter complex conditional statements that can quickly become hard to follow. But fear not! There's a neat trick we can use to make our code more readable and maintainable: object literals. In this article, I'll explore how object literals can simplify user authentication or any related scenarios and make our code shine.

The Initial Code:

Imagine you have a chunk of code that handles user authentication using different methods such as email, social login, and one-time passwords (OTP). Let's take a look at the initial code:

const authenticateUser = (method, credentials) => {
    if (method === 'email') {
        this.authenticateWithEmail(credentials);
    } else if (method === 'social') {
        this.authenticateWithSocial(credentials);
    } else if (method === 'otp') {
        this.authenticateWithOTP(credentials);
    } else {
        throw new Error('Invalid authentication method.');
    }
};

const authenticateWithEmail = (credentials) => {
    // Here's where we authenticate using email credentials
};

const authenticateWithSocial = (credentials) => {
    // Here's where we authenticate using social credentials
};

const authenticateWithOTP = (credentials) => {
    // Here's where we authenticate using OTP credentials
};

Refactoring with Object Literals:

To make our code cleaner and easier to read, we can leverage the power of object literals. Let's rewrite the code using this approach:

const authenticationMethods = {
    email: this.authenticateWithEmail,
    social: this.authenticateWithSocial,
    otp: this.authenticateWithOTP
};

const authenticateUser = (method, credentials) => {
    const authenticate = authenticationMethods[method];

authenticate ? authenticate(credentials) : throw new Error('Invalid authentication method.');
};

Let's Break it Down:

In our refactored code, we create an object literal called authenticationMethods. This handy object maps each authentication method to its corresponding authentication function. By doing this, we can easily access the appropriate authentication function based on the provided method.

Gone are the days of tangled if-else statements or lengthy switch cases. With object literals, our code becomes cleaner and more readable. If a new authentication method pops up in the future, all we need to do is update the authenticationMethods object without touching the authenticateUser function.

Conclusion:

By utilising object literals, we can transform complex conditional statements into elegant and readable code. In this article, we've seen how this technique simplifies user authentication scenarios. Embracing this approach not only enhances the maintainability of our code but also makes it more understandable and enjoyable to work with.

I'd love to hear your thoughts and answer any questions you might have. So go ahead, give it a try, and let me know how object literals elevate your code to new heights!

Alternate views

Suggested by @jonrandy

The object literal is a bit of overkill here, since you effectively already have it on this. So, it can be made even simpler:

const authenticateUser = (method, credentials) => {
  const methodName = `authenticateWith${method[0].toUpperCase() + method.slice(1)}`
  return (this[methodName] || ()=>{ throw new Error('Invalid authentication method.') })(credentials)
}

This way also scales to new authentication methods without having to change the code (providing you stick to the naming convention you provided) - making it more maintainable still.