DEV Community: Anish Ghimire

Cat Character Image - Generated Using Google's Nano Banana

Anish Ghimire — Wed, 14 Jan 2026 10:03:32 +0000

Meet our new cat character 🐱✨

Lovable, expressive, and built for storytelling, happy moments and real emotional depth.

Generated using Google’s Nano Banana with a custom character prompt, designed for reuse across multiple videos.

What should we name this little legend? 👀🎬

Cloudflare Outage - 18th November 2025

Anish Ghimire — Tue, 18 Nov 2025 17:38:53 +0000

One month after the major AWS outage, today the internet experienced an outage from Cloudflare, which provides a range of internet services.

We really don’t realize how many web applications depend on Cloudflare until the service provider stops working. From DNS management to deployments, Cloudflare has reached the point where it can power the complete web infrastructure. Some of the downtime detectors that were supposed to alert site owners about the downtime were impacted as well.

But the good thing is, Dane Knecht, the CTO of Cloudflare, has confirmed on X that the issue has been resolved.

Dane writes:

I won’t mince words: earlier today we failed our customers and the broader Internet when a problem in @Cloudflare network impacted large amounts of traffic that rely on us. The sites, businesses, and organizations that rely on Cloudflare depend on us being available and I apologize for the impact that we caused.

Transparency about what happened matters, and we plan to share a breakdown with more details in a few hours. In short, a latent bug in a service underpinning our bot mitigation capability started to crash after a routine configuration change we made. That cascaded into a broad degradation to our network and other services. This was not an attack.

That issue, impact it caused, and time to resolution is unacceptable. Work is already underway to make sure it does not happen again, but I know it caused real pain today. The trust our customers place in us is what we value the most and we are going to do what it takes to earn that back.

The apologetic and regretful tweet clearly shows Dane’s seriousness and sense of accountability.

Such outages impact millions of users, ranging from individuals to businesses. At times, such situations are unavoidable, and what’s important is how we handle these tough periods and our willingness to fix the underlying issues.

Dane further said that the team was able to resolve the issue, which was their first priority, and are now monitoring the services to ensure everything is fully operational. They also plan to share a complete walkthrough of what went wrong.

That's all for this blog. Stay tuned, and we'll come back with another blog featuring an in-depth analysis of what caused the incident at Cloudflare.

AI Agents - Introduction and Customer Support AI Agent Example

Anish Ghimire — Tue, 14 Oct 2025 15:04:47 +0000

Artificial Intelligence is growing at a very fast pace. The surge in transformer-based models like GPT, Qwen and Gemini, along with open-source innovations, has accelerated advancements in generative AI much faster than in other branches of AI. AI Agents have played a vital role in the growth and adoption of AI.

In this blog, we'll discuss the following topics:

AI Agent Introduction
Types of AI Agents
Connection of AI Agents with Generative AI
Why are AI Agents required?
An Example of AI Agent In Customer Support
Customer Support AI Agent Implementation with NodeJS and Ollama

What is an AI Agent?

An Artificial Intelligence (AI) Agent is a software program that can perceive its environment, make decisions, and autonomously perform tasks to achieve predefined or dynamic goals.

Types of AI Agents

AI agents can be categorized into four types:

Reactive Agents

Reactive agents react to immediate stimuli without memory of past interactions. Examples include autonomous vacuum cleaners and traffic light systems that change based on a set timer.

Goal-Based Agents

Goal-based agents plan actions to achieve specific goals. They modify their strategies as needed to reach their desired outcome. Autonomous vehicles, game-playing agents, etc., are examples of goal-based agents.

Utility-Based Agents

Utility-based agents aim to maximize overall utility or value. They seek to optimize their performance. A self-driving car can be an example of a utility-based agent if it makes decisions that reduce travel time and fuel consumption.

Learning Agents

Learning agents learn from their environment and improve their performance through interaction. Learning agents are not explicitly programmed to handle every scenario.

Recommendation systems, such as those of Netflix and YouTube, are examples of learning agents. They learn from user behavior and adapt to changes over time.

Connection of AI Agents with Generative AI (Gen AI)

Before diving deeper into agentic AI or AI agents, let's first understand their connection with Generative AI (Gen AI).

Generative AI primarily refers to AI models that generate new content based on a given prompt and their training data. AI agents go beyond Gen AI by making decisions and taking actions autonomously.

AI agents leverage Gen AI models for intelligence and utilize external tools such as APIs, databases, and other automation systems to complete tasks.

Why are AI Agents required?

AI agents help bridge the gap between what an LLM has been trained on and the domain-specific knowledge required to solve a particular type of problem.

Custom Knowledge Access: An AI agent can be equipped with a custom knowledge base.
Tool Integration: AI agents can automate tasks beyond text generation, such as querying databases and retrieving real-time data.

AI agents are required when the system needs to be adaptable, configurable, contextually aware, capable of accessing domain-specific knowledge, and able to perform or automate certain tasks.

An Example of AI Agent In Customer Support

Consider a customer support AI Agent with its own knowledge base. For queries, the agent first checks its knowledge base. If relevant resources are found, the information is passed on to the LLM (like Qwen or Gemini) to generate a response.

In cases where there is no relevant information in the knowledge base, the AI agent responds using the LLM based solely on what it has been trained on.

In the above example, the AI agent is making the decision to use different methods (its own knowledge base or LLM) based on the information it has, which is a key characteristic of an AI agent - it takes actions autonomously to complete a task.

Customer Support AI Agent Implementation with NodeJS and Ollama

Theory can be boring, so without wasting much time, let's jump straight into a demo project.

In this project, we will set up an intelligent customer support agent with its custom knowledge base, which will be responsible for assisting users with support-related tasks.

For demonstration purposes, we’ll set up a NodeJS project and store the knowledge base in a JSON file. We'll use the Qwen2.5 LLM model through Ollama.

The NodeJS program serves as the middleware between the AI model and the end user.

The below-mentioned knowledge.json file is an example of a knowledge base for the demonstration in this blog.

{
  ...,
  "Change Password": "To change your password, please navigate to https://sarvalekh.com/change-password",
  "Activate Account": "To activate your account, you need to upload an identity card by navigating to https://sarvalekh.com/activate"
}

The knowledge base can come in various formats, such as a site's FAQs, databases, images, audio, video, PDFs, and more. Since LLMs are primarily designed to work with text-based data, additional processing steps are required when the knowledge base is not in text format.

We first read the content of the knowledge base from the knowledge.json file. The knowledge base contains domain-specific information that is generally not included in the training data of an LLM or may not be available on the internet.

let knowledgeBase = {}
fs.readFile('knowledge.json', 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading knowledge base:', err)
  } else {
    knowledgeBase = JSON.parse(data)
  }
})

Once the knowledge base is loaded, we handle user queries and interact with the Ollama API.

async function runQuery(query) {
  const knowledgeContent = JSON.stringify(knowledgeBase)
  const prompt = `
  You are an intelligent customer support agent. Your goal is to assist users by providing accurate, clear, and concise answers based on the knowledge base you have access to.

  Here is the knowledge base:
  ${knowledgeContent}

  Use this knowledge to answer the user's query as accurately as possible. If the query is unclear or there is no direct answer in the knowledge base, inform the user politely and suggest alternatives or ask for clarification.

  The user has asked: "${query}"

  Please provide a helpful response.
  `

  try {
    const response = await axios.post('http://localhost:11434/api/generate', {
      model: 'qwen2.5',
      prompt: prompt,
      temperature: 0.7,
      stream: false,
    })

    return response.data?.response || 'Answer not found.'
  } catch (error) {
    console.error('Error querying Ollama:', error)
    return 'Sorry, there was an error processing your request.'
  }
}

The knowledge base is converted into string format and included in the prompt. The prompt guides the LLM to act as a customer support agent and use the knowledge base to answer the user’s query.

Once the model completes processing the query and a response is generated, we return the generated response.

We’ve come to the final part of the code, where we will set up the (/query) API endpoint that listens for POST requests, processes the user's query, and then returns the response from the LLM to the user.

app.post('/query', async (req, res) => {
  const query = req.body.query.trim()

  const response = await runQuery(query)
  res.json({ response })
})

When a POST request is sent to the (/query) endpoint with I am unable to activate my account the agent responds with a reply generated using the domain-specific knowledge base.

curl -X POST http://localhost:3000/query \
     -H "Content-Type: application/json" \
     -d '{"query": "I am unable to activate my account.."}'

The source code for the demo project can be found here.

With this, we’ve come to the end of the blog. We demonstrated a basic customer support agent using Ollama and NodeJS. The possibilities are unlimited, but this should serve as a good starting point for anyone wanting to learn about Artificial Intelligence.

An introduction to Generative Artificial Intelligence (Gen AI)

Anish Ghimire — Sat, 05 Apr 2025 12:16:16 +0000

In our previous blog, we discussed the introduction to Artificial Intelligence, AI’s brief history, types, branches, and examined how the different branches of AI work together through a real-world example of virtual assistants like Siri and Alexa.

What is Generative AI (Gen AI)?

Generative AI or Gen AI is a branch of AI that is focused on generating content. It can generate content like text, images, code, audio, video, and more for a given prompt. Gen AI generates content based on patterns it has learned from large datasets.

Gen AI has various applications across different domains. Text generation is one of the key applications of Gen AI. The following are some other important applications of Gen AI:

Text Generation
Image Generation
Video Generation
Code Generation
Music and Audio Generation
3D Model Generation
AI-Powered Chatbots
AI-Powered Writing and Design Tools

The Rise of Generative AI (Gen AI)

The biggest breakthrough of Generative AI can be attributed to the research paper Attention is All You Need, introduced in 2017 by Google scholars. They proposed a new simple network architecture, the Transformer.

Besides the new architecture, the availability of large datasets, improved computing power, corporate funding, and businesses finding profitable and practical use cases have all contributed to the rise and explosive growth of Gen AI in recent years.

Transformer

A transformer is a deep learning model architecture that allows processing entire sequences of text in parallel, which makes them more efficient than previous architectures like RNNs and LSTMs. GPT-3, GPT-4, BERT, and DALL-E are all built on transformer models.

The self-attention mechanism allows the model to focus on relevant words in a sentence, regardless of their position.

In the sentence “The cat sat on the mat because it was comfortable,” a traditional model struggles to understand that “it” refers to “the mat,” but a Transformer assigns attention scores to different words, helping it understand relationships more effectively.

How does Generative AI (Gen AI) work?

Gen AI generates new content by learning patterns from large amounts of data. Gen AI goes through two training phases:

Pre-training

The Gen AI model is trained on large datasets.

Fine-tuning

After pre-training, the model is refined using domain-specific datasets and human feedback. ChatGPT was fine-tuned with Reinforcement Learning from Human Feedback (RLHF) to provide more human-like responses.

Once trained, the AI processes user prompts, applies its learned knowledge, and, using Transformer architecture, generates new text, images, or code in real time.

How Machine Learning (ML), Neural Networks (NNs), and Natural Language Processing (NLP) Work Together with Generative AI

Gen AI relies on other branches of AI, such as Machine Learning (ML), Neural Networks (NNs), and Natural Language Processing (NLP), to function.

Machine Learning (ML)

Gen AI models are trained using machine learning models to learn patterns from large datasets in order to create meaningful content.

It learns patterns, grammars, and how words are structured to generate a response.

Neural Networks (NNs)

Gen AI uses neural networks, particularly deep learning, to identify patterns, interpret data, and make decisions.

Large language models like GPT-4 use transformers to process input and predict the next best word based on its training.

Natural Language Processing (NLP)

Gen AI uses natural language processing to understand and structure language.

NLP techniques help the model understand the intent behind the user’s prompt, understand the structure of the language, grammar, meaning, and generate relevant, grammatically correct, and human-like responses.

To summarize, machine learning helps the model learn from a large dataset, neural networks help process the prompt and generate content, and natural language processing ensures language understanding and structure.

That's all for this blog! I hope you found it helpful as you begin your journey into Gen AI. We’ll be back soon with more content, so stay tuned!

An introduction to Artificial Intelligence

Anish Ghimire — Thu, 20 Mar 2025 04:12:20 +0000

Artificial intelligence (AI) refers to computer systems or machines designed to simulate human-like intelligence, enabling them to perform tasks such as reasoning, problem-solving, learning, adaptation, perception, and decision-making.

AI systems use algorithms, data, and machine learning (a process of iterative improvement) to autonomously adapt, improve, and execute tasks. AI autonomy means an AI can operate, make decisions, and complete tasks with varying levels of human supervision .

Brief history of Artificial intelligence (AI)

The history of AI dates back to the early 1900s. From the birth of AI, its maturation, the AI boom, the AI winter, AI agents, and up to the present day, we have come a long way.

AI development experienced rises and falls multiple times; dozens of companies failed, and it was widely believed that the technologies were not viable. During this period, AI was primarily used behind the scenes.

The current buzz and success surrounding AI can be attributed to advanced technologies, powerful processors and hardware like GPUs, improved algorithms, and the availability of large datasets.

Narrow AI vs. General AI

There are various types of AI, but in this blog, we'll focus on two: Narrow AI and General AI

Narrow AI (Weak AI)

Narrow AI (or weak AI) is a type of artificial intelligence specialized in performing a limited set of tasks . Examples include:

Voice assistants like Siri or Alexa.
Recommendation systems (e.g., YouTube, Netflix).
Tesla’s driver-assist system (Autopilot).

These systems excel at specific tasks but lack general intelligence.

General AI (AGI or Strong AI)

Artificial General Intelligence (AGI), also called Strong AI, is a theoretical form of AI that would possess human-level intelligence. It could:

Reason, solve problems, and perform any intellectual task a human can do .
Learn new skills dynamically, similar to human adaptability.

AGI remains hypothetical, and no real-world examples exist today . Current AI systems are all Narrow AI.

How does Artificial Intelligence (AI) work?

AI works by simulating human intelligence in computer systems or machines. It makes use of algorithms, data, and computational power to simulate human-like intelligence, learn, solve problems, make decisions, recognize patterns, and more.

To understand how AI works, let's look at some of the foundational elements that make AI function:

Data

AI relies on large datasets. The data is used for training and decision-making. The quality and quantity of data directly influence the performance of AI models.

The data can be either structured, such as data from databases, or unstructured, such as images, audio, etc.

Algorithm

Algorithms are sets of instructions or rules that determine how AI should process the data and learn from it. Some examples include supervised learning, unsupervised learning, and reinforcement learning.

Neural Networks

Neural networks are computational models inspired by the human brain. They are designed to make decisions in a manner similar to the human brain. Neural networks rely on training data to learn and improve their accuracy over time. They are widely used in deep learning and natural language processing.

Training

Training in the context of AI refers to teaching an AI model to perform a specific task or set of tasks. Training involves a process of trial and error, and as training progresses, the AI models need to be fine-tuned.

Inference

Inference is the stage where AI performs its intended task based on what it has learned.

Now that we've discussed how AI works by using data, algorithms, neural networks, training, and inference, let's dive deeper into three key branches of AI where these different components of an AI system come together: Machine Learning (ML), Natural Language Processing (NLP), and Neural Networks (NN).

Branches of Artificial Intelligence (AI)

AI is a vast and multifaceted field, which is why the need for different branches of AI arises. Each branch focuses on solving specific types of challenges using particular techniques, tools, and approaches.

Machine Learning (ML)

Machine Learning (ML) is a branch of AI that focuses on enabling computer systems or machines to learn from data without being explicitly programmed. ML allows systems to simulate the way humans learn, perform tasks autonomously, and improve their performance through experience and exposure to large datasets.

There are three major categories of machine learning methods: supervised learning, unsupervised learning, and reinforcement learning.

Neural networks, linear regression, logistic regression, clustering, and decision trees are some of the commonly used machine learning algorithms.

For instance, recommendation systems (such as those used by Netflix, YouTube, etc.) use ML to analyze user behavior (data), apply algorithms to find patterns, and suggest personalized recommendations (inference).

Neural Networks (NN)

A neural network (NN) is a machine learning model inspired by the human brain, consisting of interconnected nodes (neurons) that process information through weighted connections and layers. Neural networks are a part of machine learning and enable tasks such as pattern recognition, speech processing, and decision-making.

A basic neural network typically consists of three layers:

Input Layer : Receives the raw data
Hidden Layer(s) : Processes the data
Output Layer : Provides the final result

Deep Learning (DL)

Deep Learning is a specialized subfield of neural networks. Deep Learning and neural networks are often used interchangeably, which can lead to confusion. The word deep in deep learning refers to the depth of layers in a neural network.

A neural network that has only two to three hidden layers is considered a basic neural network, while a neural network with more than three layers is referred to as a deep learning model.

For example, self-driving cars use neural networks to process visual data (data), recognize objects, pedestrians, traffic signs, and other vehicles (training), and make real-time traffic decisions (inference).

Natural Language Processing (NLP)

Natural Language Processing (NLP) is a branch of AI that focuses on enabling computer systems or machines to understand and communicate in human language.

NLP allows computer systems or machines to recognize, understand, interpret, and generate human language in a way that is both meaningful and useful. NLP combines computational linguistics, machine learning, and deep learning models to process human language.

Some approaches to NLP include Supervised NLP, Unsupervised NLP, Natural Language Understanding (NLU), and Natural Language Generation (NLG).

NLP is being utilized to automate various tasks, such as processing and analyzing large datasets, running chatbots, and more.

How Machine Learning (ML), Neural Networks (NNs), and Natural Language Processing (NLP) Work Together

Now that we've explored machine learning, neural networks, and natural language processing as key branches of AI, let's see how they all come together in a real-world application.

To make the picture clearer, let's take the example of a virtual assistant like Siri or Alexa answering a question about the weather.

Step 1: You ask Siri, "Hey Siri, what's the weather like today?"

Once you ask Siri about the weather, it uses NLP to convert your spoken words into text. This part is called speech recognition.

Step 2: Understanding the text

The system behind Siri uses NLP and neural networks to understand what you are asking.

NLP breaks down the sentence into smaller parts, identifying that you are asking about the weather and that you want information for today.

Neural networks help in recognizing patterns. For instance, they might identify that the word "weather" is associated with querying an external weather API.

Modern NLP often uses transformers (a type of neural network, such as BERT or GPT) to understand the context and relationships between words.

Step 3: Learning from past interactions

The role of ML comes into play when deciding what to do next based on what it has learned. The virtual assistant uses ML to improve over time by learning from past interactions. The ML algorithms analyze patterns in user queries to predict the best response or action.

Step 4: Fetching the weather data

The system fetches the weather information for today. A neural network might be used to process the query and decide which API to call. For example, the system sends a request to a weather API and retrieves the current temperature.

Step 5: Generating a response

Once the weather API provides the current weather details, such as (23, "degrees", "celsius", ["sunny", "comfortable"]), the system combines the data to form a grammatically correct sentence structure.

For example, it might form a sentence like: The weather today is sunny and comfortable with a high of 23 degrees Celsius.

Here, NLP helps to generate the response, and neural networks ensure the response is contextually appropriate.

Step 6: Converting Text to Speech

As a final step, the virtual assistant speaks the response back to you. NLP converts the generated response into speech using a process called Text-To-Speech (TTS). Neural networks are often used in TTS to make the voice sound more natural and human-like.

That's it! We have come to the end of the introductory blog on AI. I hope the blog will be helpful for anyone who wants to begin their journey of learning about AI. We'll be coming up with more exciting content on AI soon!

Bun Runtime - Building Nuxt app with Bun (Part 2)

Anish Ghimire — Mon, 15 Apr 2024 12:27:36 +0000

In our previous blog on the Bun Runtime series we briefly discussed Bun runtime, its installation process, scaffolding new projects, and the way to run them.

In this part, we’ll be setting up a new Nuxt application with Bun.

Bun supports Nuxt out of the box so we can use nuxi cli to initialize a Nuxt project.

Run the following command to initialize a new Nuxt project:

bunx nuxi init my-nuxt-app

The command is throwing Node version incompatibility errors during the initialization since the project setup is trying to use NodeJS instead of Bun. In this case, we can set the target to bun and re-run the command.

To setup the project using Bun add --bun flag just after bunx and run the command again:

bunx -–bun nuxi init my-nuxt-app

Once we’ve set the project you can navigate to the new project directory and run the bun –bun run dev to start the development server.

Make sure to pass the target as bun with flag --bun otherwise, Bun will spin up a node process to execute the program.

Our dev server is already up and running so we can visit localhost:3000 to see our Nuxt app running behind the new Bun runtime. ;)

In this blog, we’ve set a Nuxt project using Bun. I hope this blog helps you with setting up a Nuxt app using Bun.

In the next part of this blog, we'll be deploying the Nuxt app we created using a server and deployment management tool called Cleavr, with Bun as the runtime.

Bun Runtime - Introduction (Part 1)

Anish Ghimire — Sun, 14 Apr 2024 06:02:41 +0000

Bun is a JavaScript runtime built to serve the modern JS ecosystem. Aside from being a JavaScript runtime, Bun is a bundler, test runner, and NodeJS-compatible package manager.

While NodeJS remains a stable and popular choice as a runtime for JavaScript and TypeScript apps, Bun prioritizes speed and developer experience.

Without further delay, let's jump in and install Bun so that we can explore more of what it has to offer.

I’ll be using the Ubuntu 22.04 server from Hetzner throughout this blog. If you’re on a different platform please visit Bun’s installation documentation.

To install Bun run the following command on your terminal:

curl -fsSL https://bun.sh/install | bash

As you can see in the screenshot, I successfully installed Bun. And the download path is in ~/.bun/bin/bun.

Since Bun is installed as a root user, other system users may be unable to use Bun.

As you can see in the screenshot above, I was able to run the bun –version command while the root user was running the command. As soon as I switched the user to cleavr, which is a non-root user, I was unable to run the same command.

To resolve this issue, you can copy the Bun installation to the /usr/local/bin/ directory. The /usr directory stores read-only files that can be shared among system users.

cp /root/.bun/bin/bun /usr/local/bin/bun

Once you’ve successfully installed Bun, you can start building your projects using Bun. To scaffold an empty project, run the bun init command.

The bun init command asks you to provide answers to a few prompts, you can provide the input or just press enter to accept the default answer for each prompt.

It creates the required files to scaffold a minimal Bun project such as package.json, index.ts file, etc.
At the end it also runs bun install to install the required dependencies.

You can now run bun run index.ts to execute a source file.

In this blog, we’ve installed the Bun runtime, scaffolded, and ran a new project using Bun runtime. I hope this blog helps you with setting up and running your projects using Bun.

In the next part of this blog, we’ll set up a Nuxt application with Bun.

This content was originally posted on Cleavr.

Install MariaDB 10.4 on an Ubuntu 22.04 server

Anish Ghimire — Thu, 13 Apr 2023 09:21:54 +0000

In this blog, we’ll show you how to install MariaDB 10.4 on Ubuntu 22.04 servers.

We ran into some issues with MariaDB 10.4 installations on Ubuntu 22.04 servers. The MariaDB team stopped producing the deb package of MariaDB 10.04 for Ubuntu 22.04 servers. In Cleavr, we always want our users to have a better experience, so we planned to implement an alternate installation to either downgrade the versions of some security-related packages or a straightforward installation which takes almost 25-30 minutes 😬.

However, We didn’t want to compromise installations nor to take so much of users time. So we decided not to support MariaDB 10.4 moving forward.

However, if you still need to install MariaDB 10.4 on your Ubuntu 22.04 server, we’ll show you how you can do this using MariaDB Binary Tarballs. If you want to download any other unsupported versions of MariaDB, you can still follow this blog.

Here’s a summary of what we will be doing throughout this blog:

SSH into the server
Create system user and group
Download MariaDB binary tarballs
Extract the archive
Create a symlink to point to MySQL
Initialize the MariaDB data directory
Fix ownership
Export path to include mysql binary
Configure MariaDB server
Configure data directory
Start MariaDB service
Check MariaDB status
Enable MariaDB service

SSH into the server

As a first step, SSH into the server as a root user and add create a mysql user so that we can install MariaDB under the user and group mysql.

Create system user and group

Run the following command to create a new group and user called mysql:

groupadd mysql
useradd -g mysql

Download MariaDB binary tarballs

Now, we'll change our directory to /usr/local with cd /usr/local. This is the default directory where MariaDB is installed. So we’ll be downloading the binary tarballs in this directory. To download the tar file run the following wget command:

wget https://mirrors.aliyun.com/mariadb//mariadb-10.4.28/bintar-linux-systemd-x86_64/mariadb-10.4.28-linux-systemd-x86_64.tar.gz

If you’re following this blog and intending to download 10.3, or any other versions, just replace the version number and run the command.

For example, if you want to install MariaDB 10.3.38 the command will be:

wget https://mirrors.aliyun.com/mariadb//mariadb-10.3.38/bintar-linux-systemd-x86_64/mariadb-10.4.28-linux-systemd-x86_64.tar.gz

The download may take around 25-30 minutes to complete depending on your internet connection.

Extract the archive

Once the file is downloaded, extract the files using the tar command.

tar -zxvpf mariadb-10.4.28-linux-systemd-x86_64.tar.gz

Let's rename the extracted file to mariadb10.4 for convenience.

mv mariadb-10.4.28-linux-systemd-x86_64 mariadb10.4

Create a symlink to point to MySQL

Now let's create a symlink of the mariadb10.4 and point to mysql. /usr/local/mysql is the default location for MariaDB though it may be different in some platforms. Creating the symlink will also help you if you decide to change the MariaDB version.

ln -s /usr/local/mariadb10.4 mysql

Initialize the MariaDB data directory

We need to initialize the MariaDB data directory and create the system tables. Run the following command to change the directory to mysql, initialize the MariaDB data directory, and create the system tables:

cd mysql && ./scripts/mysql_install_db --user=mysql

Fix ownership

We need to fix the ownership of our new files. Run the following chown commands:

chown -R root .
chown -R mysql data

Export path to include mysql binary

We’ll now export the path where mysql exists by updating the .bashrc file. We’ll then be able to test the connection by invoking clients such as mysql.

Run the following command to add the export path to .bashrc file:

echo "export PATH=$PATH:/usr/local/mysql/bin/" >> ~/.bashrc

Run source ~/.bashrc so that you don’t have to restart your shell to reflect the new changes.

Configure MariaDB server

You can configure mysqld (the MariaDB server) by copying the mysql.server file to the right place.

cp support-files/mysql.server /etc/init.d/mysql.server

Next, we need to copy the mariadb.service file to its proper place.

cp support-files/systemd/mariadb.service /usr/lib/systemd/system/mariadb.service

Configure data directory

By default the /usr/ directory is write protected by systemd, so let's make our data directory writable.

mkdir /etc/systemd/system/mariadb.service.d/

cat > /etc/systemd/system/mariadb.service.d/datadir.conf <<EOF
[Service]
ReadWritePaths=/usr/local/mysql/data
EOF

Once you run the above command reload the systemd manager configuration by running systemctl daemon-reload command.

Start MariaDB service

Finally, we can start the MariaDB service using:

systemctl start mariadb.service

Check MariaDB status

Let's verify our installation by checking the status of MariaDB by running:

systemctl status mariadb

Enable MariaDB service

If you want MariaDB to start automatically when you boot up your device enable the service by running:

systemctl enable mariadb.service

That’s all for this blog. I hope it helps you with MariaDB 10.4 installation on your Ubuntu 22.04 server.

This blog was originally posted on Cleavr Slice

TWO-FACTOR AUTHENTICATION (2FA) IMPLEMENTATION IN ADONISJS

Anish Ghimire — Thu, 01 Dec 2022 10:00:59 +0000

In this blog, we’ll be discussing Two-Factor Authentication (2FA), and show you how we implemented 2FA in Cleavr using a demo project with the AdonisJS web framework.

Two-factor Authentication adds an extra layer of security to your online accounts by requiring an additional login credential in addition to a username and password. Instead of immediately gaining access after entering a username and password, users will be required to provide another piece of information, such as a PIN that’s sent through SMS or by using tokens retrieved from 2FA applications such as Google Authenticator.

As a demonstration, I’ve created a demo application in which you can enable 2FA for an account. You can view the complete source code of the application here

The following are the list of activities that we’ll be doing throughout the blog:

Migrating the Database
Updating Model
Creating a User Controller to enable 2FA
Creating an Auth Provider class
Generating the QR Code
Setting up an account on 2FA Applications
Two Factor Challenge

Migrating the Database

First, we need to store the secret and recovery codes of a user enabling 2FA. We’ll create a database migration to add two_factor_secret and two_factor_recovery_codes properties to the users table.

table.text("two_factor_secret").nullable();
table.text("two_factor_recovery_codes").nullable();

Updating Model

We don’t want to store these credentials in plain text on our database and don’t want to serialize the model properties. Update the User model with the following block of the code. Models are located under app/Models.

@column({
   serializeAs: null,
   consume: (value: string) => (value ? JSON.parse(Encryption.decrypt(value) ?? '{}') : null),
   prepare: (value: string) => Encryption.encrypt(JSON.stringify(value)),
 })
 public twoFactorSecret?: string

 @column({
   serializeAs: null,
   consume: (value: string) => (value ? JSON.parse(Encryption.decrypt(value) ?? '[]') : []),
   prepare: (value: string[]) => Encryption.encrypt(JSON.stringify(value)),
 })
 public twoFactorRecoveryCodes?: string[]

serializeAs: null removes the model properties from the serialized output.

Encryption is a module provided by AdonisJS which helps with the encryption and decryption of previously encrypted values.

Creating a User Controller to enable 2FA

Now, let’s create a controller that handles enabling two-factor authentication.

export default class UserController {
  public async enableTwoFactorAuthentication({ auth, view }) {
  const user = auth?.user

  user.twoFactorSecret = TwoFactorAuthProvider.generateSecret(user)
  user.twoFactorRecoveryCodes = await TwoFactorAuthProvider.generateRecoveryCodes()
  await user.save()
}

Here we are generating secret and recovery codes for the user that’s enabling 2FA and storing them to our database.

Creating an Auth Provider class

I’ve created a class TwoFactorAuthProvider where the logic related to 2FA is located. Lets see how the generateSecret and generateRecoveryCode methods look like:

const twoFactor = require(‘node-2fa’)
import cryptoRandomString from 'crypto-random-string'

class TwoFactorAuthProvider {
  private issuer = Config.get('twoFactorAuthConfig.app.name') || 'adonisjs-2fa'

  public generateSecret(user: User) { const secret = twoFactor.generateSecret({ name: this.issuer, account: user.email })
  return secret.secret }

  public async generateRecoveryCodes() {
    const recoveryCodeLimit: number = 8
    const codes: string[] = []
    for (let i = 0; i < recoveryCodeLimit; i++) {
      const recoveryCode: string = `${await this.secureRandomString()}-${await this.secureRandomString()}`
      codes.push(recoveryCode)
    }
    return codes
  }

  public async secureRandomString() {
   return cryptoRandomString.async({ length: 10, type: 'hex' })
  }
}

To create the secret, we’re using the generateSecret method provided by node-2fa package. You can install the package for your project by running the npm command npm install node-2fa --save.

generateSecret will generate a user-specific 32-character secret. We’re providing the name of the app and the user’s email as parameters for the function. This secret key will be used to verify whether the token provided by the user during authentication is valid or not.

We also generated recovery codes which can be used in case we’re unable to retrieve tokens from 2FA applications. We assign the user a list of recovery codes and each code can be used only once during the authentication process. The recovery codes are random strings generated using the cryptoRandomString library which can be installed using npm install crypto-random-string --save.

Generating the QR Code

Once we generate the secret and recovery codes, we should provide users with a way to add the account to an authenticator application such as Google Authenticator. To easily set up an account with such authenticator applications, we’ll be providing them with a QR code. Authenticator applications generate a time-based one-time token, which is provided to the app or site during the login process when you’ve enabled 2FA for your account.

We’ll be using qrcode NPM package for generating a QR Code. It can be installed using npm i --save-dev @types/qrcode for TypeScript projects or npm install qrcode --save.

const twoFactor = require(‘node-2fa’)

class TwoFactorAuthProvider {
  // ...
  public async generateQrCode(user: User) {
    const appName = encodeURIComponent(this.issuer)
    const userName = encodeURIComponent(user.email)
    const query = `?secret=${user.twoFactorSecret}&issuer=${appName}`
    const url = `otpauth://totp/${appName}${userName}${query}`
    const svg = await QRCode.toDataURL(url)
    return { svg, url }
  }
}

Make sure that the issuer, email and secret are valid and match the values you’ve used while generating the secret. If they don’t match you may see a Key not recognized error while scanning the QR code.

Setting up an account on 2FA Applications

We need to return the QR code from our UserController’s enableTwoFactorAuthentication method so the frontend can show the QR to the user for setting up the account on 2FA applications.

export default class UserController {
  public async enableTwoFactorAuthentication({ auth, view }) {
    // …
    return view.render('pages/settings', {
      status: {
      type: 'success',
      message: 'Two factor authentication enabled.',
    },
    twoFactorEnabled: user.isTwoFactorEnabled,
    code: await TwoFactorAuthProvider.generateQrCode(user)
  })
}

In the UI, you can show the QR code using the HTML image tag.

<div>
  <img src="{{ code.svg }}" />
</div>

Additionally, you can also send the recovery codes with the same response and show the codes.

Two Factor Challenge

Now the most important part of 2FA begins. We need to ask for a one-time token with the users that have 2FA enabled when they log in.

First, we’ll verify whether the credentials supplied by users are valid or not. If the credentials are valid, we proceed to check whether 2FA is enabled or not. In the case where 2FA is enabled, we redirect users to the Two Factor Challenge page where they’ll be asked to provide a one-time token or a recovery code. In other cases, we log in the users directly.

export default class AuthController {
  public async login({ request, response, auth, view, session }) {
    const { email, password } = request.only(["email", "password"]);
    const user = await auth.use("web").verifyCredentials(email, password);

    if (user.isTwoFactorEnabled) {
      session.put("login.id", user.id);
      return view.render("pages/two-factor-challenge");
    }

    session.forget("login.id");
    session.regenerate();
    await auth.login(user);
    response.redirect("/");
  }
}

We’re storing the user ID in the session before redirecting the user to the two-factor challenge page so that we’re aware of the user who is trying to authenticate.

Once the user is on the two-factor challenge page, the user will be asked to enter either a token or a recovery code. Then, once the submit button is clicked we need to verify that either the token or recovery code is valid for the user or not.

export default class AuthController {
  // …
  public async twoFactorChallenge({ request, session, view, auth, response }) {
    const { code, recoveryCode } = request.only(["code", "recoveryCode"]);
    const user = await User.query()
      .where("id", session.get("login.id"))
      .first();

    session.forget("login.id");
    session.regenerate();

    if (code) {
      const isValid = await twoFactor.verifyToken(user.twoFactorSecret, code);
      if (isValid) {
        await auth.login(user);
        return response.redirect("/");
      }
    } else if (recoveryCode) {
      const codes = user?.twoFactorRecoveryCodes ?? [];
      if (codes.includes(recoveryCode)) {
        user.twoFactorRecoveryCodes = codes.filter(c => c !== recoveryCode);
        await user.save();
        await auth.login(user);
        return response.redirect("/");
      }
    }
  }
}

What goes here is, we receive the 2FA code provided by the user and find the user using the user ID stored in the session. We’ll be using the verifyToken method provided by node-2fa. It then checks if a time-based token matches a token from the secret key. In the case of recovery codes, we check whether the recovery code provided by the user exists in our system for the user or not, and then remove the recovery code once it has been used. Don’t forget to clear the session variables once the login process completes.

That’s it! Your users can now enable 2FA for their accounts and enjoy the additional security it provides. The code used in this blog is available over on here. I hope you found this blog useful.

How to setup a Tunneling server using Cleavr

Anish Ghimire — Thu, 24 Mar 2022 06:13:08 +0000

On Cleavr, the majority of activities take place on the user's servers. For many of these activities, such as server provisioning and deployments, we show the status real-time status on the Cleavr UI.

But, how do we communicate the activities that are taking place on the user's server?

If it's in production, we can send status updates between servers, which is a relatively straightforward process.

However, for local development, we use a tunneling server to expose our local application to the internet.

There are plenty of tunneling solutions that can be used for local development, such as: Ngrok, Localtunnel, and Expose.

But, these solutions will impose certain restrictions at some level.

Today, we’re going to discuss how we can create our own tunneling server using Cleavr. During the writing of this blog, I found an article that was helpful to me and that I used as a reference.

The good news about owning your own tunneling server is that you won’t have to worry about some headaches such as frequently changing sub-domains,having a random subdomain being assigned, or experiencing frequent disconnections.

To begin setting up our own tunneling server, we'll first provision a new server with the bare minimum specs so that we won’t have to spend a lot of money on this solution.

You can also make use of Cleavr’s free domain instead of purchasing a custom one for some added savings.

Now, it’s time to create a site in which we’ll expose our local site/app on the internet.

Head over to your newly provisioned server and click on Add Site.

For the App Type, select Generic Port App.

Provide your domain name, desired port number and user as well. If you’re using a custom domain, we encourage you to enable free SSL.

Once you’ve created your site, you can now go to the newly created site and navigate to the Site NGINX Config page. On this page, update the config required for our tunneling site to work. You can simply update the NGINX config with the following contents:

map $http_upgrade $connection_upgrade {
   default upgrade;
   ''      close;
}

server {
   server_name example.cleavr-one.com;
   include cleavr-conf/example.cleavr-one.com/*.conf;

   location / {
       proxy_pass http://localhost:PORT;
       proxy_set_header X-Real-IP $remote_addr;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header Host $http_host;
       proxy_set_header X-NginX-Proxy true;

       # Enables WS support
       proxy_http_version 1.1;
       proxy_set_header Upgrade $http_upgrade;
       proxy_set_header Connection $connection_upgrade;
   }
}

Be sure to update example.cleavr-one.com with your domain name and PORT with the port number you’ve used during site creation.

Now, click the update button and you will be done with the configuration part and the most boring part for some of you 😉.

We’re almost done, but if we stop right here you’ll have to enter your server password every time you want to expose your local server to the internet.

Cleavr provides a way to add your SSH keys to the Server directly from the UI. You just need to go to Server > SSH Keys and add your SSH key to the server.

We’re all done now. Lets expose our local server to the internet with the following command:

ssh -N -R SITE_PORT:localhost:LOCAL_PORT serverUser@serverIP

BOOM!!! Now you can open your site example.cleavr-one.com in a browser, and you’ll see your local app being loaded there.