Forem: Akshay Kaushik

Enhance Linux Performance: Step-by-Step Guide to Increase Swap File Space

Akshay Kaushik — Fri, 05 Jan 2024 08:25:24 +0000

In Linux, swap space allows the system to utilize disk storage for memory management. When the system is running low on physical RAM, it can temporarily move data from memory to swap space on the hard drive.

Increasing swap file size provides more “breathing room” for memory and can improve system performance when running memory-intensive applications.

This article explains what swap space is, why you may need to increase it, and a step-by-step process to resize the Linux swap file using the command line.

What is swap space?

Think of swap space as a temporary storage area that your computer uses when it's running out of physical memory (RAM). It's like a lifeboat for your system when it's drowning in heavy applications.

When to increase swap space

There are a few common cases when increasing Linux swap space can improve performance:

Memory intensive workloads: Applications like data analysis with Pandas, machine learning with NumPy and SciPy, and product analytics with Apache Spark require significant memory. Increasing swap space prevents slow downs when working with large datasets.
Multitasking with many applications: Running multiple applications causes increased memory utilization. More swap space ensures smooth concurrent execution.
Susceptibility to memory exhaustion: Some Linux servers are vulnerable to denial-of-service attacks using up memory. Added swap space gives breathing room to recover safely.
Prevent out-of-memory kernel panics: In extreme cases, Linux can completely run out of memory and kernel panic. Extra swap prevents this server crash by allowing graceful degradation.

Check your current swap space utilization to determine if your system needs more swap area on disk.

Check current swap usage

swapon --show

This command displays the Linux swap partitions and files currently in use along with their size in kilobytes. It also shows the total swap memory utilization across all swap areas on disk.

If swap usage is close to 100% or you’re getting out-of-memory errors, increase the swap size.

Disable the swap file

sudo swapoff /name.swap

Before resizing an existing swap file, it needs to be temporarily disabled with the swapoff command.

This stops the OS from writing new swap data so the file can be safely manipulated.

Create a new larger swap file

sudo dd if=/dev/zero of=/name.swap.tmp bs=1024 count=2097152

Use the dd command to quickly create a new 2GB file to use as larger swap space.

We give this file a temporary name like name.swap.tmp to avoid overwriting the old swap file before the changeover is complete.

Rename and replace the old swap file

sudo mv /name.swap /name.swap.old
sudo mv /name.swap.tmp /name.swap

Now that the new swap file is created, rename the original swap file to a backup name like name.swap.old.

Then rename the new name.swap.tmp file to the original swap file name name.swap.

Set permissions on the new swap file

sudo chmod 600 /name.swap

The new swap file needs its permissions changed to allow only root read/write access for security reasons. The chmod command does this quickly.

Re-enable the new swap file

sudo mkswap /name.swap
sudo swapon /name.swap

Initialize the new swap file using mkswap, then enable it for use with swapon.

The system can now start utilizing the new, larger swap space.

Verify the new swap file size

swapon --show
free -h

Check swapon and free commands to confirm your newly resized swap file is reported correctly.

You should see the increased swap size along with lower utilization percentage.

Reboot the system

sudo reboot

After completing the swap file resizing steps, safely reboot Linux to allow services and applications use the added memory.

FAQs

1. Why is increasing swap file size beneficial?

- It provides extra 'virtual' memory, which helps your system handle more applications simultaneously.

2. Can I increase my swap file size without rebooting the server?

- No, you need to reboot the server for changes to take effect.

3. What if my swap space is not showing any increase after following these steps?

- Try disabling and re-enabling the swap space again.

4. Is there any limit to how much I can increase my swap file size?

- Yes, it is recommended that your swap space does not exceed 2x the size of your physical RAM.

5. Can I decrease my swap file size in the same way?

- Yes, follow these same steps but specify a lower value when resizing the swap file.

I require immediate work. Entry-level is also acceptable.

Things to Note Before Migrating Servers

Akshay Kaushik — Wed, 03 Jan 2024 07:39:20 +0000

As technology evolves, it becomes necessary for developers to migrate servers. Whether it's upgrading to a more powerful server or downgrading to a more cost-effective solution, the process remains the same.

Recently, I have migrated my server, holding multiple projects based on WordPress, Nextjs, and Django.

I am sharing with you the steps that I followed.

Check the Node/Python Versions

The first step is to document the current Node.js and Python versions running on the existing server. Different applications may require specific major versions, so migrating to a new server with incompatible versions can cause applications to break.

You can check your Node version using node -v and Python version with python --version. Note these versions and make sure your new server can support them.

Review requirements.txt and package.json

Dependencies are external modules that your project relies on.

In Python projects, these are listed in a requirements.txt file
while in Node. They're in the package.json.

When migrating servers, it's essential to reinstall these dependencies so your application continues to work as intended. Keep a copy of these files and use them to install dependencies on the new server.

Migrate Supplementary Services

In addition to the main web frameworks, apps often depend on supplementary services like databases, queues, caches, etc. Common ones include:

Relational databases (PostgreSQL, MySQL)
In-memory caches (Redis, Memcached)
Background job queues (Celery, RabbitMQ)
Search indexes (Elasticsearch, Solr)

Document all active services being utilized. During migration, ensure these services are properly set up on the new server and test their functionality before going live.

Audit File/Folder Permissions

Server permissions determine who can access what resources on your server. Apps need proper filesystem permissions to startup, read configurations, write logs, etc. Over time, permissions might diverge on an existing server from the defaults.

Before migrating, audit the permission levels required for key folders like:

The application codebase
Log directories
Writable temp file areas

Make a list of all users and their permissions from the current server and replicate it on the new one.

Match the Web Server Version

Web servers like Nginx and Apache turn app code into usable websites and APIs. Confirm the new server is running a compatible web server release.

For example, Ubuntu runs Apache by default. If apps require Nginx, you may need to manually install a newer version before migrating those sites.

Also, export and migrate any custom web server configurations that handle things like:

Custom headers
URL rewriting
Rate limiting
Virtual hosts

Adhering to the expected web server version avoids inadvertent issues.

Environment File

Environment files (.env) store sensitive information like API keys and database credentials. These files shouldn't be exposed publicly. During migration, don't forget to copy this file and check that it's correctly referenced in your application.

Ensure all required variables get ported from the old to the new server. Good options are:

Direct transfer of .env files
Exporting/importing variables from a key/value store

Test that migrated apps pick up the configurations as expected post-move.

Review Cron Jobs

Scheduled cron jobs inevitably get added over time for ops tasks like database backups, log rotations, scheduled jobs, etc.

Document all cron jobs on the original server before moving. Transfer any custom scripts referenced over to the new server as well.

After migrating, review that scheduled jobs are firing as expected in the new environment. Troubleshoot any paths/permissions getting in the way.

Project Specific Services

Running apps in the background requires using process managers like systemd or PM2 in Node and gunicorn in Python.

Gunicorn for Python Projects

Gunicorn acts as a web server gateway interface (WSGI) HTTP server for Python web applications. If your Django projects use Gunicorn, ensure it's properly installed and configured on the new server.

PM2 for Node.js Projects

PM2 is a process manager for Node.js applications that allows you to keep applications running forever. If your NextJS projects use PM2, ensure it’s correctly set up on your new server.

Perform Database Migrations

Database migration is a critical aspect of server migration. Ensure data consistency by correctly backing up your database from the current server and restoring it to the new one.

For relational SQL databases, perform a database dump from the old server and import it into the new database. Review for errors and test data integrity post-move.
For in-memory stores like Redis, manually transfer data or leverage built-in migration capabilities.
For search indexes like Elasticsearch, many support native snapshotting of indexes to restore new clusters.

Validate that connections exist between migrated apps and databases post-transition.

Configure Load Balancers

In multi-server environments, load balancers distribute requests across app servers. When migrating servers:

Add the new server to the load balancer pool but disable traffic to it.
Migrate apps to the new server, and validate health checks pass.
Gradually shift traffic mix towards the new server.
Retire the old server once stable.

This ensures no downtime for end users. Review load balancer logs for errors during the migration process.

User Acceptance Testing (UAT): Putting the User Experience First

Before switching over to the new server, conduct comprehensive user acceptance testing (UAT) to ensure that all systems and applications are functioning as expected from the user's perspective. This UAT phase should involve testing all critical functionalities, including user authentication, data access, and performance.

DNS Cutover and Go-Live: Making the Big Leap

Once UAT is successfully completed, initiate the DNS cutover process, updating DNS records to point to the new server's IP address. Monitor the migration closely during this transition phase to address any potential issues promptly.

I require immediate work. Entry-level is also acceptable.

Avoid These 6 Common React useState Hook Mistakes (Code Example)

Akshay Kaushik — Fri, 29 Dec 2023 16:30:08 +0000

As a React developer, you're probably familiar with the UseState hook. It's a powerful tool that allows you to add state to your functional components. However, it's easy to make mistakes when using it. In this article, we'll explore the most common mistakes and how to avoid them.

Let's walk through the 6 most common useState mistakes, ranging from conceptual errors to subtle syntax issues, and learn how to avoid them through clear examples. Understanding these common pitfalls will level up your React skills.

1. Not Understanding How useState Works

The useState hook returns an array with 2 elements. The first element is the current state value, while the second element is a state setter function.

It's important to understand that useState does not merge object state updates - it completely overwrites state.

View this example:

import React, {useState} from 'react';

function MyComponent() {
  const [state, setState] = useState({
    name: 'John',
    age: 20 
  });

  const handleUpdate = () => {
    // This will overwrite existing state 
    setState({
      name: 'Sam' 
    });
  }

  return (
    <div>
      {/*Renders 'Sam' instead of 'John' after handleUpdate call*/}  
      <h1>{state.name}</h1> 
      <h2>{state.age}</h2>

      <button onClick={handleUpdate}>Update Name</button>
    </div>
  );
}

To merge state updates correctly, pass an updater function to setState:

setState(prevState => {
  return {...prevState, name: 'Sam'} 
});

2. Passing Functions Inline

It's convenient to pass functions inline to event handlers or effects, but doing this breaks updating state:

import {useState, useEffect} from 'react';

function MyComponent() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    // Closures prevent this from working
    document.addEventListener('click', () => setCount(count + 1));
  }, []);

  return <h1>{count}</h1>;
}

Since function closures are created on each render, count never updates properly.

Pass functions inline only if they don't update state.

Instead, declare them outside or in useCallback():

// Outside
function increment() {
  setCount(count + 1);
}

// In useCallback() 
const increment = useCallback(() => {
  setCount(count + 1); 
}, []);

3. Forgetting to Handle Arrays and Objects Correctly

Another mistake is mutating state arrays or objects directly:

const [tags, setTags] = useState(['react', 'javascript']);

const addTag = () => {
  // Mutates existing array 
  tags.push('nodejs');  
}

return <div>{tags}</div>

Since the tags array was mutated directly, React can't detect changes and won't trigger re-renders properly.

Instead, create a new copy of array/object before passing to setter function:

const addTag = () => {
  setTags([...tags, 'nodejs']);  
}

Spread syntax [...array] shallow copies the array. This lets React detect changes.

4. Making Unnecessary useState Calls

There's no need to separate every single field or data point into its own state hook. Doing so hurts performance unnecessarily:

function MyForm() {
  const [firstName, setFirstName] = useState(''); 
  const [lastName, setLastName] = useState('');

  return (
    <>
      <input 
        value={firstName}
        onChange={(e) => setFirstName(e.target.value)}
      />

      <input
        value={lastName}  
        onChange={(e) => setLastName(e.target.value)} 
      />
    </>
  );
}

Instead, group related state into single objects:

function MyForm() {
  const [fields, setFields] = useState({
    firstName: '',
    lastName: '' 
  })

  // Call once to update both name fields
  const handleChange = (e) => {
    setFields({
      ...fields,
      [e.target.name]: e.target.value 
    })
  }

  return (
    <>
      <input 
        name="firstName"
        value={fields.firstName}
        onChange={handleChange} 
      />

      <input 
        name="lastName"
        value={fields.lastName}
        onChange={handleChange}
      /> 
    </>
  );  
}

5. Incorrect State Comparison

When dealing with objects or arrays, avoid direct comparisons for state changes.

// Incorrect
if (user !== newUser) {
  // ...

// Correct
if (user.id !== newUser.id) {
  // ...

6. Not Setting a Proper Initial State

It's important to initialize state properly:

1. Initialize based on props

Rather than hard-coding values:

// Hard-coded
const [count, setCount] = useState(0); 

// Initialise based on props
const [count, setCount] = useState(props.initialCount);

2. Handle unloaded data

If fetching data in useEffect, set loading state:

const [user, setUser] = useState(null);

useEffect(() => {
  fetchUser().then(user => setUser(user))  
}, []);

// Check for null before rendering
return <div>{user ? user.name : 'Loading...'}</div>

This avoids errors from rendering undefined state.

3. Specify data types for state

Typing state helps avoid issues:

const [count, setCount] = useState<number>(0);
const [user, setUser] = useState<{name: string} | null>(null);

This ensures you prevent passing an invalid updated state value to setter functions.

Bookmark this as a handy useState troubleshooting guide. And most importantly, pay special attention to problem areas like spreading arrays before setting state, not mutating objects directly, understanding how useState batching.

Mastering useState fundamentals takes your React game to the next level!

Frequently Asked Questions

Q: Why call a function to update state instead of changing it directly?

A: Calling the setter function lets React trigger re-renders. It also queues up state changes for more reliable batching.

Q: How do you update object state properly?

A: Either replace the state completely by passing a new object, or shallow merge by spreading the previous state. Never directly mutate state objects.

Q: When should useCallback be used with state setters?

A: Use it if passing the setter down in a callback or effect to prevent unnecessary recreations between renders.

Q: What's the difference between passing a value vs updater function to setState?

A: Value replaces state wholly while updater merges by taking previous state as first argument of function.

Q: Why spread arrays/objects before updating state?

A: Spreading creates a copied version React can watch for changes, avoiding issues with mutation.

I require immediate work. Entry-level is also acceptable.

Merge Multiple Git Repositories without Breaking File History

Akshay Kaushik — Tue, 12 Dec 2023 09:12:52 +0000

Merging separate Git repositories into a single combined repository is a common need for developers. For example, you may have a frontend and backend repository that are part of the same overall application, but kept in separate repositories during initial development.

Bringing these components together into a single repository makes it easier to view, manage, and work with the full codebase as a unified project. However, preserving the commit history and being able to trace code changes back to their original repository is also important.

The Problem

So, your current setup looks like this:

You've got separate Git repositories for frontend and backend, and now you want to make the Parent Folder the main repository housing both, all while preserving commit histories. Sounds like a plan! Let's dive into the solution.

Steps to Solve

1. Create a New Repository

First things first, let's create a new repository on GitHub (or your preferred hosting service). This will be the main repository for your combined project.

git clone https://github.com/your-username/combined-repo.git
cd combined-repo

# OR In case of offline

git init combined-repo
git remote add origin https://github.com/your-username/combined-repo

Replace "your-username" and "combined-repo" with your GitHub username and the new repository's name. This allows you to pull commits from the source repositories using the remote names as references.

2. Add Remotes

Now, add remotes for both "frontend" and "backend" repositories:

git remote add frontend /path/to/frontend
git remote add backend /path/to/backend

Replace /path/to/frontend and /path/to/backend with the actual paths to your frontend and backend repositories, whether they are offline or online.

3. Fetch Commits

Fetch the commits from both repositories:

git fetch frontend
git fetch backend

This pulls the branches and associated commits into your local repository without actually merging anything.

With the commits fetched, you can start merging each repository one at a time.

4. Merge Frontend

Create and switch to a new branch for frontend:

First, make a branch for each incoming repository:

git checkout -b frontend-merge frontend/master

Now merge the branch while allowing unrelated histories between the new repo and old repos:

git merge --allow-unrelated-histories FETCH_HEAD

The --allow-unrelated-histories flag is crucial to allow merging branches that do not share a common starting commit.

Next, create directories for the frontend, and move the files accordingly from the merged branches:

mkdir frontend
git ls-tree -z --name-only HEAD | xargs -0 -I {} git mv {} frontend/
git commit -m "Merge frontend repository into combined-repo"

Commit to each step. Keeping the code organized this way keeps things isolated during additional merging later.

5. Repeat for Backend

Repeat the process for the backend repository:

git checkout -b backend-merge backend/master
git merge --allow-unrelated-histories FETCH_HEAD
mkdir backend
git ls-tree -z --name-only HEAD | xargs -0 -I {} git mv {} backend/
git commit -m "Merge backend repository into combined-repo"

6. Merge and Resolve Conflicts

Now, let's bring it all together:

git checkout master
git merge frontend-merge
git merge backend-merge

As files are brought together from different repositories, merge conflicts can happen just like during normal development.

Code changes from different sources may modify the same parts of a file in incompatible ways. When this happens, Git stops the merge and flags the conflict.

If you encounter a "refusing to merge unrelated histories" error, use the following:

git merge --allow-unrelated-histories frontend-merge
git merge --allow-unrelated-histories backend-merge

Resolve any merge conflicts if they occur. Commit the changes:

git commit -m "Merge frontend-merge and backend-merge into master"
git push origin master

And there you have it! Your GitHub repository's master branch should now contain the combined content and commit history from both frontend and backend repositories.

I require immediate work. Entry-level is also acceptable.

Multithreading VS Multiprocessing VS Asyncio (With Code examples)

Akshay Kaushik — Sun, 10 Dec 2023 13:15:03 +0000

Concurrency refers to the execution of multiple tasks simultaneously in a program. There are primarily three ways to introduce concurrency in Python - Multithreading, Multiprocessing and Asyncio. Each approach has its advantages and disadvantages.

Choosing the right concurrency model for your Python program depends on the specific requirements and use cases. This comprehensive guide will provide an overview of all three approaches with code examples to help you decide when to use Multithreading, Multiprocessing or Asyncio in Python.

Multithreading in Python

Multithreading refers to concurrently executing multiple threads within a single process. The Python thread module allows you to spawn multiple threads in your program.

Here is an example code to understand multithreading in Python:

import threading 

def print_cube(num):
  """
  Function to print cube of given num
  """
  print("Cube: {}".format(num * num * num))

def print_square(num):
  """
  Function to print square of given num
  """
  print("Square: {}".format(num * num))

if __name__ == "__main__":
    # creating thread
    t1 = threading.Thread(target=print_square, args=(10,))  
    t2 = threading.Thread(target=print_cube, args=(10,))

    # starting thread 1
    t1.start()
    # starting thread 2
    t2.start()

    # wait until thread 1 is completely executed
    t1.join()
    # wait until thread 2 is completely executed
    t2.join()

    print("Done!")

In the above code, we create two threads t1 and t2. t1 calls print_square() function while t2 calls print_cube().

We start both the threads using start() method. join() ensures that the main thread waits for these threads to complete before terminating.

The key advantage of multithreading is that it allows maximum utilization of a single CPU core by executing threads concurrently. All threads share the same process resources like memory. Context switching between threads is lightweight.

However, multithreading also comes with challenges like race conditions, deadlocks etc. when multiple threads try to access shared resources. Careful synchronization is needed to avoid these issues.

Example of using MultiThreading in Action

Multiprocessing in Python

Multiprocessing refers to executing multiple processes concurrently. The multiprocessing module in Python allows spawning processes using an API similar to threading.

Here is an example:

import multiprocessing 

def print_cube(num):
  """
  Function to print cube of given num
  """
  print("Cube: {}".format(num * num * num))

def print_square(num):
  """
  Function to print square of given num
  """
  print("Square: {}".format(num * num))

if __name__ == "__main__":
    # creating process
    p1 = multiprocessing.Process(target=print_square, args=(10,))
    p2 = multiprocessing.Process(target=print_cube, args=(10,))

    # starting process 1
    p1.start()
    # starting process 2
    p2.start()

    # wait until process 1 is finished
    p1.join()
    # wait until process 2 is finished
    p2.join()

    print("Done!")

Here, we create two processes p1 and p2 to execute the print_square() and print_cube() functions concurrently.

The main difference between multithreading and multiprocessing is that threads run within a single process while processes run independently in separate memory spaces.

Multiprocessing avoids GIL limitations and allows full utilization of multicore CPUs. However, processes have higher memory overhead compared to threads. Interprocess communication is more complicated compared to thread synchronization primitives.

Example of MultiProcessing in Action

Asyncio in Python

Asyncio provides a single-threaded, non-blocking concurrency model in Python. It uses cooperative multitasking and an event loop to execute coroutines concurrently.

Here is a simple asyncio example:

import asyncio

async def print_square(num):
  print("Square: {}".format(num * num))

async def print_cube(num):
  print("Cube: {}".format(num * num * num))

async def main():
  # Schedule coroutines to run concurrently
  await asyncio.gather(
    print_square(10),
    print_cube(10)
  )

asyncio.run(main())

We define coroutines using async/await syntax. The event loop schedules the execution of coroutines and runs them consecutively.

Asyncio is best suited for IO-bound tasks and use cases where execution consists of waiting on network responses, database queries etc. It provides high throughput and minimizes blocking.

However, asyncio doesn't allow true parallellism on multicore systems. CPU-bound processing may suffer performance issues. It has a steep learning curve compared to threads and processes.

Threading is about workers; asynchrony is about tasks.

Key Differences

Here is a quick comparison of the three concurrency models:

Use Cases

Use multithreading when you need to run I/O-bound or CPU-bound jobs concurrently in a single process. Examples - serving concurrent requests in a web server, parallel processing in data science apps etc.
Leverage multiprocessing for CPU-bound jobs that require truly parallel execution across multiple cores. Examples - multimedia processing, scientific computations etc.
Asyncio suits network applications like web servers, databases etc. where blocking I/O operations limit performance. Asyncio minimizes blocking for high throughput.

So in summary:

Multithreading provides concurrent execution in a single process, limited by GIL
Multiprocessing provides full parallelism by executing separate processes
Asyncio uses an event loop for cooperative multitasking and minimized blocking

Choose the right concurrency model based on your application requirements and use cases.

Conclusion

Multithreading, multiprocessing and asyncio provide different approaches to concurrency and parallelism in Python.
Multithreading uses threads in a single process, multiprocessing spawns separate processes while asyncio leverages an event loop and coroutines for cooperative multitasking.
Each model has its strengths and limitations. Understanding the key differences is important to make an informed decision based on the specific problem you are trying to solve.
The code examples and comparisons highlighted in this guide should help you pick the appropriate concurrency framework for your Python programs.

FAQs

Q: What is the Global Interpreter Lock (GIL) in Python?

A: The GIL is a mutex that allows only one thread to execute Python bytecodes at a time even in multi-threaded programs. This prevents multiple threads from running simultaneously on multiple CPU cores.

Q: How can I achieve true parallelism in Python?

A: The multiprocessing module allows spawning multiple processes which can leverage multiple CPUs and cores for parallel execution. It avoids GIL limitations.

Q: When should I use multithreading vs multiprocessing?

A: Use multithreading for I/O bound tasks. Multiprocessing is best for CPU-intensive work that needs parallel speedup across multiple CPU cores.

Q: What are the differences between multiprocessing and multithreading?

A: Key differences are separate vs shared memory, different synchronization primitives, parallelism capabilities etc. Multiprocessing provides full parallelism while multithreading is limited by GIL.

Q: How does asyncio work and when should it be used?

A: Asyncio uses an event loop and coroutines for a cooperative multitasking model suited for I/O bound apps. It minimizes blocking and provides high throughput.

I require immediate work. Entry-level is also acceptable.

Setting Up Celery for Your Django Project on Ubuntu Server: A Comprehensive Guide

Akshay Kaushik — Thu, 07 Dec 2023 05:11:20 +0000

In this tutorial, we'll walk you through the process of configuring Celery, a distributed task queue, with your Django project on an Ubuntu server. Celery enables the asynchronous execution of tasks, enhancing the performance and scalability of your application. We'll break down the configuration of the celeryd and celery.service files step by step, helping even novice developers get started.

Setting Up Celery

In this section, we will dive into the crucial process of configuring Celery for your Django project. Celery is a powerful tool that enables you to run asynchronous tasks in the background, enhancing the performance and scalability of your web application.

Prerequisites

Before we proceed, make sure you have the following tools and prerequisites in place:

A working Django project.
A Linux server (in this case, we'll focus on configuring Celery on an Ubuntu server).
Python 3.x installed.
A virtual environment is set up for your Django project.

If you haven't set up your Django project or installed Python 3.x, please ensure you do so before continuing.

Creating /etc/default/celeryd

Section 1: celeryd Configuration

Create the Configuration File: To begin, navigate to the /etc/default directory and create a new file named celeryd to hold your Celery configuration.
Defining Node Configuration: Specify the number of nodes for Celery using the CELERYD_NODES variable. For most setups, a single node is sufficient:
```
CELERYD_NODES="celery"
```
Setting Celery Binary Path: Define the absolute or relative path to the Celery command using the CELERY_BIN variable. For example:
```
CELERY_BIN="/home/akshaykaushik.eu.org/AI/.venv/bin/celery"
```
Specifying Django App Instance: Set the Django app instance to be used with Celery using the CELERY_APP variable, It is the Django project name:
```
CELERY_APP="Project"
```
Setting Working Directory: Specify the directory where Celery should operate from using the CELERYD_CHDIR variable(path of directory in which Django manage.py exists):
```
CELERYD_CHDIR="/home/akshaykaushik.eu.org/AI/"
```

Configuring Logging: Define the logging level and paths for Celery logs using the following variables:

CELERYD_LOG_LEVEL="INFO"
CELERYD_LOG_FILE="/home/akshaykaushik.eu.org/AI/log/celery/%n%I.log"
CELERYD_PID_FILE="/home/akshaykaushik.eu.org/AI/run/celery/%n.pid"

Specifying User and Group: Set the unprivileged user and group for Celery workers using the following variables(user and group of the django folder):
```
CELERYD_USER="aksha1706"
CELERYD_GROUP="aksha1706"
```
Directory Creation and Permissions: Enable directory creation for missing PID and log directories and configure them to be owned by the specified user/group:
```
CELERY_CREATE_DIRS=1
```
Activating Virtual Environment: Specify the virtual environment activation command:
```
CELERYD_ENV="+/home/akshaykaushik.eu.org/AI/.venv/bin/activate"
```
Setting Permissions: To ensure the Celery worker has the necessary permissions, follow these steps:

Execute the command chmod +x /etc/init.d/celeryd.
Create the log and PID folders specified in the configuration file and grant them write permissions.
With these permissions in place, your Celery worker will operate smoothly.

# most people will only start one node:
CELERYD_NODES="celery"

# Absolute or relative path to the 'celery' command:
CELERY_BIN="/home/akshaykaushik.eu.org/AI/.venv/bin/celery"

# App instance to use
CELERY_APP="Project"

# Where to chdir at start.
CELERYD_CHDIR="/home/akshaykaushik.eu.org/AI/"

# Set logging level to INFO
CELERYD_LOG_LEVEL="INFO"

# %n will be replaced with the first part of the node name.
CELERYD_LOG_FILE="/home/akshaykaushik.eu.org/AI/log/celery/%n%I.log"
CELERYD_PID_FILE="/home/akshaykaushik.eu.org/AI/run/celery/%n.pid"

# Workers should run as an unprivileged user.
CELERYD_USER="aksha1706"
CELERYD_GROUP="aksha1706"

# If enabled, PID and log directories will be created if missing,
# and owned by the userid/group configured.
CELERY_CREATE_DIRS=1

# Activate the virtual environment
CELERYD_ENV="+/home/akshaykaushik.eu.org/AI/.venv/bin/activate"

Creating a systemd Service for Celery

Section 2: celery.service Configuration

Create the Service File: Navigate to the /etc/systemd/system directory and create a new file named celery.service.
Defining the Unit: In the celery.service file, describe the service and set its dependencies:
```
[Unit]
Description=Celery Service
After=network.target
```
Configure the Service: Define the service type, user, group, and reference the celeryd configuration file:
```
[Service]
Type=forking
User=aksha1706
Group=aksha1706
EnvironmentFile=/etc/default/celeryd
```

Set Working Directory and ExecStart: Specify the working directory and the command to start the Celery service:

WorkingDirectory=/home/akshaykaushik.eu.org/AI
ExecStart=/bin/bash -c "source /home/akshaykaushik.eu.org/AI/.venv/bin/activate && \
  /home/akshaykaushik.eu.org/AI/.venv/bin/celery multi start ${CELERYD_NODES} \
  -A Project --pidfile=${CELERYD_PID_FILE} \
  --logfile=${CELERYD_LOG_FILE} --loglevel=${CELERYD_LOG_LEVEL}"

Define ExecStop and ExecReload: Specify the commands to stop and reload the Celery service:

ExecStop=/bin/bash -c "source /home/akshaykaushik.eu.org/AI/.venv/bin/activate && \
  /home/akshaykaushik.eu.org/AI/.venv/bin/celery multi stopwait ${CELERYD_NODES} \
  --pidfile=${CELERYD_PID_FILE}"
ExecReload=/bin/bash -c "source /home/akshaykaushik.eu.org/AI/.venv/bin/activate && \
  /home/akshaykaushik.eu.org/AI/.venv/bin/celery multi restart ${CELERYD_NODES} \
  -A Project --pidfile=${CELERYD_PID_FILE} \
  --logfile=${CELERYD_LOG_FILE} --loglevel=${CELERYD_LOG_LEVEL}"

Define Installation: Specify the target for installation:
```
[Install]
WantedBy=multi-user.target
```

    [Unit]
    Description=Celery Service
    After=network.target

    [Service]
    Type=forking
    User=aksha1706
    Group=aksha1706

    EnvironmentFile=/etc/default/celeryd
    WorkingDirectory=/home/akshaykaushik.eu.org/AI
    ExecStart=/bin/bash -c "source /home/akshaykaushik.eu.org/AI/.venv/bin/activate && \
      /home/akshaykaushik.eu.org/AI/.venv/bin/celery multi start ${CELERYD_NODES} \
      -A Project --pidfile=${CELERYD_PID_FILE} \
      --logfile=${CELERYD_LOG_FILE} --loglevel=${CELERYD_LOG_LEVEL}"
    ExecStop=/bin/bash -c "source /home/akshaykaushik.eu.org/AI/.venv/bin/activate && \
      /home/akshaykaushik.eu.org/AI/.venv/bin/celery multi stopwait ${CELERYD_NODES} \
      --pidfile=${CELERYD_PID_FILE}"
    ExecReload=/bin/bash -c "source /home/akshaykaushik.eu.org/AI/.venv/bin/activate && \
      /home/akshaykaushik.eu.org/AI/.venv/bin/celery multi restart ${CELERYD_NODES} \
      -A Project --pidfile=${CELERYD_PID_FILE} \
      --logfile=${CELERYD_LOG_FILE} --loglevel=${CELERYD_LOG_LEVEL}"

    [Install]
    WantedBy=multi-user.target

Enabling and Starting Celery

To activate and initiate Celery as a systemd service, follow these steps:

Run sudo systemctl daemon-reload to reload systemd manager configuration.
Enable the Celery service: sudo systemctl enable celery.
Start the Celery service: sudo systemctl restart celery.

With these commands, you'll have Celery up and running as a background service.

Running Celery

To use Celery with your Django project, you need to run it. After activating the virtual environment and navigating to your Django project folder, execute the following command:

celery -A CELERY_APP_NAME worker -l INFO

Make sure to replace CELERY_APP_NAME with your actual project name. This command initiates Celery as a worker, ready to process tasks.

In case you need to make changes or updates, rerun the three commands mentioned above. This ensures that your Celery service remains active and responsive.

Conclusion: Congratulations! You've successfully configured Celery for your Django project on an Ubuntu server. The celeryd and celery.service files are now optimized to handle asynchronous tasks efficiently. By following these detailed steps, even newcomers to development can set up Celery with ease. Don't forget to run the specified commands to finalize the configuration and enjoy enhanced performance and scalability for your Django application. Happy coding!

I require immediate work. Entry-level is also acceptable.