1. Create an empty folder on your computer.
2. Open Vs Code and go to your folder.
3. Run the following command: “npm init -y”
4. This command will initialize a node js app in that folder by creating the package.json file.
5. Then, install your required dependencies by running the following command: “npm install <package-name>”
6. Ex: npm install express, npm install nodemon
7. Nodemon is a utility that monitors for any changes in your source code and automatically restarts your server. It is particularly useful during development because it saves you from having to manually restart your server every time you make changes to your code.
8. You can edit the package.json file to accomodate the automatic startup using nodemon.
9. Use the following vanilla package.json with nodemon to create a basic Node js server.
10. Now, you can create an index.js file in the same folder and then write some code like a console statement and run the following command to start the node js server: “npm run dev”

{
  "name": "backend",
  "version": "1.0.0",
  "description": "Real Time Data Processing node js app",
  "type": "module",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
}

MERN stack refers to the technologies required to build a Full-Stack application.

In this article, we are going to discuss two of the technologies:

NodeJs and MongoDB.

NodeJs is JS runtime environment (basically serves as Backend in the MERN web application).

MongoDB is the NoSql DB we are going to connect.

Prerequisites:

1. Docker
2. Node Js
3. Mongo DB

Steps:

1. Pull the Mongo DB docker image -> docker pull mongo:6
2. Setup the docker-compose.yml file.
3. Run the docker-compose file to create the Docker container.
4. Use mongosh (Mongo Shell) to interact with MongoDB.

docker-compose.yml

version: '3.1'

services:

  mongo:
    image: mongo:6
    container_name: mongo-mern
    restart: always
    ports:
      - "27017:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: root
      MONGO_INITDB_ROOT_PASSWORD: root
      MONGO_INITDB_DATABASE: bookstore-mern

After the docker container gets created, run this following command to use the Mongo Shell to interact with Mongo DB :

The structure:

docker exec -it <container-name> mongosh -U <user> -d <db-name>

docker exec -it mongo-mern mongosh -U root -d bookstore-mern 

The Mongo shell opens up like this and then you can create your DB using the “use <db-name>” command.

You can also create a DB user of your own and give the necessary permissions:

Command to create a DB user:

 db.createUser({ user: "mongo-mern-user", pwd: "root", roles: [ { role: "readWrite", db: "bookstore-mern" }] })

Here are the simple steps to connect to a Postgres DB using Docker.

We are going to use docker-compose to configure the DB connection.

This is the docker-compose.yml file used to connect to the Postgres DB:

docker-compose.yml

version: '3'
services:
  postgres:
    image: postgres:latest
    container_name: postgres-jwt-auth
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: "postgres"
      POSTGRES_PASSWORD: "postgres"
      POSTGRES_DB: postgres-jwt

In this .yml file, we are defining the environment variables needed to establish a connection to the Postgres DB.

The env variables used are:

1. User
2. Password
3. DB name

POSTGRES_USER
POSTGRES_PASSWORD
POSTGRES_DB

The default port for postgres is “5432”

We need to specify the docker image as well in the image section of the .yml file.

We have specified “postgres:latest” which means the latest docker image for postgres is pulled from DockerHub and run in the docker container.

We can also specify the optional container-name.

That’s it. This is all we need to configure to run Postgres on Docker.

Now, we need to trigger the below command to run the Docker container:

 docker-compose up -d 

The Docker container has started and is running now.

You can also verify if the container is running by running the below command:

docker ps

Now that the docker container with Postgres image is up and running, we are can use the psql CLI to enter the Postgres DB and perform SQL queries.

This is the psql command to enter the DB in Postgres:

docker exec -it postgres-jwt-auth psql -U postgres -d postgres-jwt

Now, we have successfully created a Postgres DB using Docker.

The scope of this article was just to demonstrate how to setup and run Postgres DB using docker on your computer.

Now, you can successfully connect to the Postgres DB and run your SQL queries according to your needs.

For example, in Spring Boot(Java) we use application.yml / application.properties to store this information and then we retrieve these details whenever required.

In Golang, the simplest way to achieve this is to use the .env file.

How to do it?

Steps:

1. Create a .env file in the project structure.
2. Then, declare your properties in the following format.

YOUR_PROPERTY_NAME=PROPERTY_VALUE

3. These properties can be accessed in .go files using the “os” package.

See example below:

We stored the username and password required to connect to Rabbit Mq in the .env file and then accessed these properties in main.go file using the following two packages:

1. “github.com/joho/godotenv”
2. “os”

The godotenv package enables us to load the .env file and then we can use “os.Getenv(“Property Name”)” to access the specific property.

Read more about the godotenv package here: https://pkg.go.dev/github.com/joho/godotenv

Read more about the os package here:

https://pkg.go.dev/os

GitHub - rahulgubili3003/go-fiber-basic-app

This is the GitHub link to my Go Fiber basic API code.

What is Go Fiber?

Go Fiber is a web framework designed for Go, built on top of Fasthttp, known for its speed and efficiency. It aims to simplify web development in Go by focusing on minimalism and performance.

The code below is the snippet from the main.go file which uses the Go Fiber framework to create a basic API that responds with a Json response on the path “/ping”.

The server runs on port 3000.

package main

import (
 "github.com/gofiber/fiber/v2"
 "log"
)

func main() {
 // Initialize
 app := fiber.New()

 // Accepts the request on this path and return the Json value as mentioned
 app.Get("/ping", func(c *fiber.Ctx) error {
  return c.JSON(fiber.Map{
   "message": "Hello, we are using Go Fiber!!",
  })
 })

 // Listen on Port 3000
 err := app.Listen(":3000")
 if err != nil {
  log.Fatal(err)
 }
}

Testing the API on Postman:

In this article, I shall explain how to connect to PostgreSQL Database from a Go program using the standard database/sql package.

Prerequisites:

1. Docker
2. GO

Steps:

1. Pull the docker image for PostgreSQL from DockerHub using the below command.

docker pull postgres

You will see this message after the docker image download is complete.

Status: Downloaded newer image for postgres:latest

2. After the docker image is pulled, then, instantiate a Docker container.

docker run --name go-postgres-demo -e POSTGRES_PASSWORD=password -p 5432:5432 -d postgres

This command creates a Docker container with name “go-postgres-demo” and runs the postgres docker image on the port 5432:5432.

3. Run “docker ps” command to verify if the docker container is up and running.

You will see something like this:

 docker ps                                                                                 
CONTAINER ID   IMAGE      COMMAND                  CREATED                  STATUS         PORTS                                       NAMES
24702b257d23   postgres   "docker-entrypoint.s…"   Less than a second ago   Up 3 seconds   0.0.0.0:5432->5432/tcp, :::5432->5432/tcp   go-postgres-demo

4. Now, run a command to create a DB in Postgres.

docker exec -ti go-postgres-demo createdb -U postgres postgres-demo

This will create a DB called “postgres-demo”.

5. You can actually verify the connection to the newly created DB using the psql command.

docker exec -ti go-postgres-demo psql -U postgres

6. Execute the following commands to successfully verify the connection to the DB.

psql (16.3 (Debian 16.3-1.pgdg120+1))
Type "help" for help.

postgres=# \c postgres-demo
You are now connected to database "postgres-demo" as user "postgres".
postgres-demo=# \q

7. Now, the DB has been successfully created and we are able to verify the connection to that DB is happening successfully.

8. Now, we write a Go program to connect to the DB that we just created. See below for the Go program:

package main

import (
 "database/sql"
 "fmt"
 _ "github.com/lib/pq"
 "log"
)

func main() {
 fmt.Println("Starting connection with Postgres Db")
 connStr := "postgres://postgres:password@localhost:5432/postgres-demo?sslmode=disable"
 db, err := sql.Open("postgres", connStr)
 defer db.Close()
 if err != nil {
  log.Fatal(err)
 }
 if err = db.Ping(); err != nil {
  log.Println("DB Ping Failed")
  log.Fatal(err)
 }
 log.Println("DB Connection started successfully")
}

This is a basic program in Go to connect to the Postgres DB.

Go output after successful DB connection:

Starting connection with Postgres Db
2024/05/12 11:49:23 DB Connection started successfully

Github: https://github.com/rahulgubili3003/postgres-with-go

gRPC is a modern open source high performance Remote Procedure Call (RPC) framework developed by Google that can run in any environment.

It allows communication between clients and severs written in completely different languages. This is possible because gRpc uses Protocol Buffer (protobuf) files.

Protocol Buffers are a language-neutral, platform-neutral extensible mechanism for serializing structured data.

It’s like JSON, except it’s smaller and faster.

The format and structure of the .proto files (extension for the protocol buffer definition files) are same regardless of what language you are using the gRpc framework in.

That’s why Protocol Buffers are language and platform agnostic.

Now, how do these .proto files look? And, what is their structure and how are they defined?

Example of protobuf file (grpc-service.proto)

syntax = "proto3";

option go_package = "./proto";
package proto;

message Request {
  int64 id = 1;
  string firstname = 2;
  string lastname = 3;
}

message Response {
  string message = 1;
}

service RegisterService {
  rpc RegisterUser(Request) returns (Response) {}
}

Syntax breakdown:

The first line of the protobuf file consists of ‘syntax = “proto3”’.

Then, we define the structure of the data that is expected to be received and sent over the gRpc.

We define this request and response structure using the keyword ‘message’.

The ‘message’ block defines the structure of the data. Within it, we define certain fields depending on our requirement. In this example, ‘Request’ has 3 fields id, firstname and lastname. And, the data type is also defined along with declaration.

Similarly, we define for Response as well.

Then, we define the ‘Service’.

Our application will have a service called RegisterService which has a function called RegisterUser which accepts the Request and Response as defined.

The package defined at the top of the file denotes the package in which this grpc-service.proto file is present.

After finishing the definition of our .proto file, we need to compile this using the protoc compiler which then generates 2 golang files (pb.go)

Command:

protoc --go_out=. --go-grpc_out=. proto/grpc-service.proto

Then, run go mod tidy so that if there are any missing dependencies, they will be automatically added.

Simple explanation:

A web server accepts client requests and sends responses accordingly. A client could be anything from web browsers to API clients like Postman etc.. These requests are served over the Web using protocols like HTTP/HTTPS.

So, now we are going to create a basic web server using Golang. This webserver accepts requests from the client over the web and generates some pre-defined responses.

Prerequisites:

1. Install Golang on your computer(Latest Version)

Check if Golang is installed on your computer by using this command:

go version

If it is already installed, then you will get the following response on your terminal showing the installed Golang version.

go version go1.22.1 darwin/amd64

Let’s start coding for the web server.

Note: In this example, we are going to create a Http server which accepts the request from the web client and then just prints a pre-defined (hardcoded) output.

Steps:

1. Create an empty directory.
2. Then initiate the go.mod file with the module name of your choice. (go mod init <module-name>)
3. Then under the /main sub-directory create the main.go file. (The main.go file is the main entry point of the application from where the program execution starts)
4. We need to import two modules (“fmt” and “net/http”) -> The net/http module in Go is a package that provides functionalities for creating HTTP clients and servers.
5. Then, we need to create a Handler function that prints the output based on a specific route.
6. After writing the entire code. Run the main function. The Web server gets initiated and you can basically test from the browser or Postman.

See detailed code below:

main.go

package main

import (
 "fmt"
 "net/http"
)

func main() {
 http.HandleFunc("/basic", handler)
 // Listen on port 8080
 fmt.Println("Server is listening on port 8085...")
 if err := http.ListenAndServe(":8085", nil); err != nil {
  fmt.Printf("Error starting server: %v\n", err)
 }
}

func handler(w http.ResponseWriter, r *http.Request) {
 _, err := fmt.Fprintf(w, "Welcome to the basic Http server")
 if err != nil {
  return
 }
}

go.mod file

module github.com/rahulgubili3003/basic-web-server-go

Project structure:

Test the web server:

Definition:

What are Utility classes?

In our application, when we encounter a situation where we have to perform a certain function/operation multiple times, then instead of writing that piece of repetitive logic in all instances, we can simply delegate that logic to an external class.

Note: Here, external does not mean external to the project, but, creating a separate utility class under a separate “util” directory.

So, we write this repetitive method/function/logic in the utility class.

What is the structure of the utility class?

It is an ordinary class like any other class in your application, but, while defining the utility methods in this class we need to keep a few things in mind.

The utility methods in this utility class should be static.

This is more of a code convention followed widely in the industry.

Ex:

In the below code snippet, you can see that a BuilderUtil class has been defined and it has 2 static methods to build a couple of Entity objects.

You can note that both methods are static.

Utility methods are static for mainly the following reasons:

1. Statelessness: Utility classes are typically stateless, meaning they do not maintain any state information. This characteristic makes them ideal for static methods, which also do not operate on an instance of a class but rather on the class itself. Static methods can be called without creating an instance of the class, which aligns with the stateless nature of utility classes.
2. Reuse Across Instances: Static methods allow for the reuse of standard behavior across instances of different classes. This is particularly useful for utility methods, which often provide common functionalities that are not tied to the state of a specific object. By being static, utility methods can be easily reused across different parts of an application without the need to instantiate the utility class. -> (Which is one of the main reasons for the creating Utility classes)

So, to summarise, the utility methods are made static because static methods can be called using just the class name without having to create an instance of the utility class whenever we want to use the utility methods.

This way, the utility methods are not tied to instances, rather, they would be universally accessible. Utility classes and methods are designed to be simple and clear, focusing on providing specific functionalities without the complexity of object-oriented programming. Static methods contribute to this simplicity by being directly associated with the class rather than an instance of the class.

Note: As a good coding practice, always create a private no-args constructor for the utility class so that the Utility class cannot be instantiated.

This design pattern ensures that utility methods are not tied to any specific instance of the class, further emphasizing their utility nature.

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class BuilderUtil {

    public static RoomEntity buildRoomEntity(@NotNull final RoomAddRequest roomAddRequest) {
        return RoomEntity.builder()
                .roomNumber(roomAddRequest.roomNo())
                .roomType(roomAddRequest.roomType().getRoomTypeId())
                .floor(roomAddRequest.floor())
                .build();
    }

    public static RoomAddResponse buildRoomAddResponse(@NotNull final RoomEntity roomAdded) {
        return RoomAddResponse.builder()
                .id(roomAdded.getId())
                .floor(roomAdded.getFloor())
                .roomNo(roomAdded.getRoomNumber())
                .roomType(RoomType.getByRoomTypeId(roomAdded.getRoomType()))
                .build();
    }
}