
## Introduction

Fiber ([gofiber.io](https://gofiber.io/)) is web framework written in Go that much like Express in Nodejs. Fiber have many built in features to build rich web application such as Middleware, API Ready, Template Engine, Websocket support, Rate limiter, etc. They used [fasthttp](https://github.com/valyala/fasthttp) for the engine that claims is the fastest HTTP Engine in Go.

Today, we are going to build a simple REST API with Fiber and integrated with PlanetScale for the database.

> PlanetScale is serverless database platform for developers that built on top Vitess.

## Set up PlanetScale

Go to [https://planetscale.com/](https://planetscale.com/) and sign up, then setup your account such as organization, etc. Then, we'll create database via PlanetScale CLI, you can also create database via web.

I don't want to explain how to setup the CLI, PlanetScale's team has managed to explain it very clear. Check out the documentation [PlanetScale CLI](https://docs.planetscale.com/reference/planetscale-cli)

Once success to setup the CLI, then create database called `fiber-pscale` and specify the region of your database. I recommended to using the region that close that where you are. In my case I would like to use Asia Pacific Singapore. You can check the list of region, there are 6 regions at the moment.

```bash
$ pscale region list
  NAME (6)                 SLUG           ENABLED
 ------------------------ -------------- ---------
  US East                  us-east        Yes
  US West                  us-west        Yes
  EU West                  eu-west        Yes
  Asia Pacific Mumbai      ap-south       Yes
  Asia Pacific Singapore   ap-southeast   Yes
  Asia Pacific Tokyo       ap-northeast   Yes
```

Create database

```bash
$ pscale database create fiber-pscale --region ap-southeast
Database fiber-pscale was successfully created.
```

## Set up Application

We are going to use [go modules](https://go.dev/blog/using-go-modules), first we create empty directory and then initialize the modules. You can use your repo url or application name. In this case, I'm using my repo url.

```bash
mkdir fiber-pscale && cd fiber-pscale

go mod init github.com/maful/fiber-pscale
```

Then, there are 3 packages we're going to build. Package means the directory. Create thress directories.

- cmd : this is the root application for initialize the Fiber and connect to PlanetScale database
- handler : contains all handler for the routing such as list data, create, etc
- models : contains data structure for the application

```bash
mkdir cmd
mkdir handlers
mkdir models
```

Since we are going to use Fiber and PlanetScale, install the modules

To access PlanetScale, we can use ORM from Go called [Gorm](https://gorm.io/), and since PlabetScale database is built on top Vitess (MySQL), install the MySQL driver as well.

```bash
# install fiber
$ go get -u github.com/gofiber/fiber/v2

# install gorm to connect to planetscale database
$ go get -u gorm.io/gorm

# mysql driver
$ go get -u gorm.io/driver/mysql
```

### Basic Handler

write basic handler with Fiber, create file called `main.go` inside cmd directory and add this script

```go
package main

import (
	"net/http"

	"github.com/gofiber/fiber/v2"
	"github.com/gofiber/fiber/v2/middleware/logger"
)

func main() {
	app := fiber.New(fiber.Config{
		AppName:      "Fiber with Planetscale",
		ServerHeader: "Fiber",
	})

	app.Use(logger.New())

	app.Get("/", func(c *fiber.Ctx) error {
		return c.Status(http.StatusOK).JSON(&fiber.Map{
			"message": "Hello world",
		})
	})

	app.Listen(":3000")
}
```

it will create a new instance of fiber server, and listen to PORT 3000, back to terminal and run the main.go

```bash
$ go run cmd/main.go

 ┌───────────────────────────────────────────────────┐
 │              Fiber with Planetscale               │
 │                   Fiber v2.18.0                   │
 │               http://127.0.0.1:3000               │
 │       (bound on host 0.0.0.0 and port 3000)       │
 │                                                   │
 │ Handlers ............. 3  Processes ........... 1 │
 │ Prefork ....... Disabled  PID ............. 22443 │
 └───────────────────────────────────────────────────┘
```

and then you can access it at `http://localhost:3000`, below is an example with curl command

```bash
$ curl --location --request GET 'http://localhost:3000'
{"message":"Hello world"}
```

you could use Postman or other similar software if prefer to use GUI.

## Models

Create User model, create file called `user.go` inside models directory, and define a struct with gorm

```go
package models

import "gorm.io/gorm"

// User struct
type User struct {
	gorm.Model
	Name    string `json:"name"`
	Email   string `json:"email"`
	Website string `json:"website"`
}
```

## Connect to Database

Create development database branch called `add-users-table`

```bash
$ pscale branch create fiber-pscale add-users-table
```

open new terminal tab, we're going to connect to database inside `add-users-table` branch and listen to `3309` PORT. See more [Connect using client certificates](https://docs.planetscale.com/tutorials/connect-any-application#connect-using-client-certificates)

```bash
$ pscale connect fiber-pscale add-users-table --port 3309
```

Create file called `database.go` inside models directory and add function to connect to database

```go
package models

import (
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

var DB *gorm.DB

func ConnectDatabase() {
	// refer https://github.com/go-sql-driver/mysql#dsn-data-source-name for details
	dsn := "root:@tcp(127.0.0.1:3309)/fiber-pscale?charset=utf8mb4&parseTime=True&loc=Local"
	database, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		panic("failed to connect database")
	}

	// Migrate the users table
	database.AutoMigrate(&User{})

	DB = database
}
```

open your main.go, and call the `ConnectDatabase` function to migrate the tables and connect to database.

```go
import (
	// ...

	"github.com/maful/fiber-pscale/models"
)

func main() {
	r := gin.Default()

	models.ConnectDatabase() // New

	// ....
}
```

then run the app `go run cmd/main.go`, Gorm will automatically migrate the table into `add-users-table` branch. How to know if the migration is success? You can check in Planetscale dashboard for the following branch, or using CLI to see the schema for `add-users-table` branch.

```bash
$ pscale branch schema fiber-pscale add-users-table
-- users --
CREATE TABLE `users` (
  `id` bigint unsigned NOT NULL AUTO_INCREMENT,
  `created_at` datetime(3) DEFAULT NULL,
  `updated_at` datetime(3) DEFAULT NULL,
  `deleted_at` datetime(3) DEFAULT NULL,
  `name` longtext,
  `email` longtext,
  `website` longtext,
  PRIMARY KEY (`id`),
  KEY `idx_users_deleted_at` (`deleted_at`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
```

this schema won't apply to main branch until you create a deploy request

lastly, stop the connection from `add-users-table` branch or `Ctrl+C`.

## Deploy the schema

now, deploy the `add-users-table` branch into main branch

```bash
$ pscale deploy-request create fiber-pscale add-users-table
Deploy request #1 successfully created.
```

check your dashboard, you'll see here that you requested schema changes from development branch to main branch. If you are familiar with Git, it kind of Pull Request.

![01](/assets/build-rest-api-fiber-planetscale/01.png)

now, approve the request and the PlanetScale automatically apply the new schema into main branch **without downtime**

```bash
$ pscale deploy-request deploy fiber-pscale 1
Successfully deployed dhacze78ukhv from add-users-table to main.
```

now, back and check the dashboard, it's deployed 🎊

![02](/assets/build-rest-api-fiber-planetscale/02.png)

if you no longer need to make schema changes from the branch, now you can safely delete it

```bash
$ pscale branch delete fiber-pscale add-users-table
```

## Handlers

create a file called `users.go` inside handlers directory.

now, create a connection to main branch so the application can communicate with the database.

```bash
$ pscale connect fiber-pscale main --port 3309
```

> Note: It's recommended to use secure connection while connecting to main branch once you deployed your application. More [https://docs.planetscale.com/reference/secure-connections](https://docs.planetscale.com/reference/secure-connections)

### Create a user

Create a function `CreateUser` and initialize `createUserRequest` struct in users.go

```go
package handlers

import (
	"net/http"

	"github.com/gofiber/fiber/v2"
	"github.com/maful/fiber-pscale/models"
)

type createUserRequest struct {
	Name    string `json:"name" binding:"required"`
	Email   string `json:"email" binding:"required"`
	Website string `json:"website" binding:"required"`
}

func CreateUser(c *fiber.Ctx) error {
	req := &createUserRequest{}
	if err := c.BodyParser(req); err != nil {
		return c.Status(http.StatusBadRequest).JSON(&fiber.Map{
			"message": err.Error(),
		})
	}

	user := models.User{
		Name:    req.Name,
		Email:   req.Email,
		Website: req.Website,
	}
	models.DB.Create(&user)

	return c.Status(fiber.StatusCreated).JSON(&fiber.Map{
		"user": user,
	})
}
```

open main.go, add a new handler to call that function

```go
import (
	// ...
	"github.com/maful/fiber-pscale/handlers"
)

// app.Get("/" ...
app.Post("/users", handlers.CreateUser)
```

run the app, and try to create the user

```bash
$ curl --location --request POST 'http://localhost:3000/users' \
--header 'Content-Type: application/json' \
--data-raw '{
    "name": "John",
    "email": "john@example.com",
    "website": "https://example.com"
}'
```

response

```json
{
    "user": {
        "ID": 1,
        "CreatedAt": "2021-09-06T20:04:31.022+07:00",
        "UpdatedAt": "2021-09-06T20:04:31.022+07:00",
        "DeletedAt": null,
        "name": "John",
        "email": "john@example.com",
        "website": "https://example.com"
    }
}
```

### List all users

create a new function called `GetUsers` below the create function

```go
func GetUsers(c *fiber.Ctx) error {
	var users []models.User
	models.DB.Find(&users)

	return c.Status(http.StatusOK).JSON(&fiber.Map{
		"users": users,
	})
}
```

register the function to the app, place above the create user handler

```go
app.Get("/users", handlers.GetUsers)
// app.Post("/users...
```

stop the existing app, and run again. You should always do this because the app doesn't refresh automatically when we made a changes.

```bash
curl --location --request GET 'http://localhost:3000/users'
```

response

```json
{
    "users": [
        {
            "ID": 1,
            "CreatedAt": "2021-09-06T20:04:31.022+07:00",
            "UpdatedAt": "2021-09-06T20:04:31.022+07:00",
            "DeletedAt": null,
            "name": "John",
            "email": "john@example.com",
            "website": "https://example.com"
        }
    ]
}
```

### View user

add a new function called `GetUser` in the bottom

```go
// ...

func GetUser(c *fiber.Ctx) error {
	var user models.User
	if err := models.DB.First(&user, "id = ?", c.Params("id")).Error; err != nil {
		return c.Status(http.StatusNotFound).JSON(&fiber.Map{
			"message": "Record not found!",
		})
	}

	return c.Status(http.StatusOK).JSON(&fiber.Map{
		"user": user,
	})
}
```

and add new handler in main.go

```go
// ...
app.Get("/users", handlers.GetUsers)
app.Get("/users/:id", handlers.GetUser) // new
```

now, we try to get the user details with id 1

```bash
curl --location --request GET 'http://localhost:3000/users/1'
```

response

```json
{
    "user": {
        "ID": 1,
        "CreatedAt": "2021-09-06T20:04:31.022+07:00",
        "UpdatedAt": "2021-09-06T20:04:31.022+07:00",
        "DeletedAt": null,
        "name": "John",
        "email": "john@example.com",
        "website": "https://example.com"
    }
}
```

if try to get the id that doesn't exist

```bash
curl --location --request GET 'http://localhost:3000/users/100'
```

```json
{
    "message": "Record not found!"
}
```

### Update a user

again, add a new function called `UpdateUser` in the users handler

```go
// ...

func UpdateUser(c *fiber.Ctx) error {
	// first, check if the user is exist
	user := models.User{}
	if err := models.DB.First(&user, "id = ?", c.Params("id")).Error; err != nil {
		return c.Status(http.StatusNotFound).JSON(&fiber.Map{
			"message": "Record not found!",
		})
	}

	// second, parse the request body
	request := &updateUserRequest{}
	if err := c.BodyParser(request); err != nil {
		return c.Status(http.StatusBadRequest).JSON(&fiber.Map{
			"message": err.Error(),
		})
	}

	// third, update the user
	updateUser := models.User{
		Name:    request.Name,
		Email:   request.Email,
		Website: request.Website,
	}
	models.DB.Model(&user).Updates(&updateUser)

	return c.Status(http.StatusOK).JSON(&fiber.Map{
		"user": user,
	})
}
```

register update user to main.go

```go
app.Put("/users/:id", handlers.UpdateUser)
```

now, re-run the application

update the user that we created before

```bash
$ curl --location --request PUT 'http://localhost:3000/users/1' \
--header 'Content-Type: application/json' \
--data-raw '{
    "name": "Machine name"
}'
```

response

```json
{
    "user": {
        "ID": 1,
        "CreatedAt": "2021-09-08T08:07:25.042+07:00",
        "UpdatedAt": "2021-09-08T08:15:52.249+07:00",
        "DeletedAt": null,
        "name": "Machine name",
        "email": "joh@example.com",
        "website": "google.com"
    }
}
```

when the user doesn't exist

```bash
$ curl --location --request PUT 'http://localhost:3000/users/100' \
--header 'Content-Type: application/json' \
--data-raw '{
    "name": "Machine name"
}'
```

response

```json
{
    "message": "Record not found!"
}
```

### Delete a user

Add delete user function in the bottom of users handler.

```go
func DeleteUser(c *fiber.Ctx) error {
	// first, check if the user is exist
	user := models.User{}
	if err := models.DB.First(&user, "id = ?", c.Params("id")).Error; err != nil {
		return c.Status(http.StatusNotFound).JSON(&fiber.Map{
			"message": "Record not found!",
		})
	}

	// second, delete the user
	models.DB.Delete(&user)

	return c.Status(http.StatusOK).JSON(&fiber.Map{
		"message": "Success",
	})
}
```

register the function

```go
app.Delete("/users/:id", handlers.DeleteUser)
```

so, create a new user again

```bash
$ curl --location --request POST 'http://localhost:3000/users' \
--header 'Content-Type: application/json' \
--data-raw '{
    "name": "Badu",
    "email": "joh@example.com",
    "website": "google.com"
}'
```

see the id from the response, we will delete that user

```bash
$ curl --location --request DELETE 'http://localhost:3000/users/2'
```

response

```json
{
    "message": "Success"
}
```

## Summary

PlanetScale offer Developer plan pricing that you can use for the development lifecycle and it's completely FREE. You can create up to 3 databases and 3 branches each database. Basically, this is going to be a new knowledge for the developer who never use serverless database and with new workflow how to make a schema.

Fiber is a great web framework to build application in Go, they are fast, rich features and the documentation is good.

In this post, it's just simple web api application to give basic understanding how to use Fiber and PlanetScale database. In the next one, we are going to build more complex web api with the same tech stacks.

Download the full source code on this [repository](https://github.com/maful/fiber-pscale).

Thank you.

Build REST API with Go Fiber and PlanetScale


## Introduction

If you actively working in web development, you may ever hear about docker and how docker makes the development are fun and the environment consistent, and isolated.

In this post, we will go through containerizing a Rails API application. Consider you already have a Rails application and you want the same environment for all your team while developing the app and here is the Docker coming in.

## Prerequisites

- Docker installed on your machine
- Rails application

## Step 1 - Create a Dockerfile

`Dockerfile` is a file that contains all the commands that users can call to build an image for the application. Since we will build an image for rails, we need to add ruby as the base image

- Create Dockerfile (without extension) inside your root project and add ruby for the base image. You can choose another version that suitable for your app (Ruby image tags)

```text
FROM ruby:2.7.3
```

- Create user and install required packages

```text
# argument
ARG WORK_DIR=/my_app
ARG USER=my_user
ARG HOME=/home/${USER}
ARG UID=999

# create user and user group
RUN groupadd -g ${UID} ${USER} && useradd -r -u ${UID} -g ${USER} ${USER}

# update os and install required packages
RUN apt-get update -qq && apt-get upgrade -y && apt-get install -y postgresql-client
```

- then, copy all necessary files from the host machine and then install the app dependencies

```text
# set WORK_DIR
RUN mkdir ${WORK_DIR}
COPY Gemfile ${WORK_DIR}/Gemfile
COPY Gemfile.lock ${WORK_DIR}/Gemfile.lock
COPY . ${WORK_DIR}
RUN chown -R ${USER}:${USER} ${WORK_DIR}

# set HOME
RUN mkdir -p ${HOME}
RUN chown -R ${USER}:${USER} ${HOME}
WORKDIR ${WORK_DIR}

# set user before bundle install for dev permission issue
USER ${USER}
RUN bundle install
```

- Add script and main process, and here we expose port 3000 from the image

```text
# Add a script to be executed every time the container starts.
USER ${USER}
COPY entrypoint.sh /usr/bin/
ENTRYPOINT ["./usr/bin/entrypoint.sh/"]
EXPOSE 3000

# Start the main process.
CMD ["rails", "server", "-b", "0.0.0.0"]
```

Here is the full our Dockerfile

```text
FROM ruby:2.7.3

# argument
ARG WORK_DIR=/my_app
ARG USER=my_user
ARG HOME=/home/${USER}
ARG UID=999

# create user and user group
RUN groupadd -g ${UID} ${USER} && useradd -r -u ${UID} -g ${USER} ${USER}

# update os and install required packages
RUN apt-get update -qq && apt-get upgrade -y && apt-get install -y postgresql-client

# set WORK_DIR
RUN mkdir ${WORK_DIR}
COPY Gemfile ${WORK_DIR}/Gemfile
COPY Gemfile.lock ${WORK_DIR}/Gemfile.lock
COPY . ${WORK_DIR}
RUN chown -R ${USER}:${USER} ${WORK_DIR}

# set HOME
RUN mkdir -p ${HOME}
RUN chown -R ${USER}:${USER} ${HOME}
WORKDIR ${WORK_DIR}

# set user before bundle install for dev permission issue
USER ${USER}
RUN bundle install

# Add a script to be executed every time the container starts.
USER ${USER}
COPY entrypoint.sh /usr/bin/
ENTRYPOINT ["./usr/bin/entrypoint.sh/"]
EXPOSE 3000

# Start the main process.
CMD ["rails", "server", "-b", "0.0.0.0"]
```

The last thing, create entrypoint.sh in your root project and add this script

```bash
#!/bin/bash
set -e

# Remove a potentially pre-existing server.pid for Rails.
rm -f /my_app/tmp/pids/server.pid

# Then exec the container's main process (what's set as CMD in the Dockerfile).
"${@}"
```

## Step 2 - Add services with Docker compose

When you want to run multiple docker containers, you should consider using Docker compose. If your app database is PostgreSQL, you can add `postgres` image to compose file.

Create file called `docker-compose.yml` in your project directory, and add our image above (Dockerfile) and postgres image to handling the database.

```yaml
version: '3'
services:
  db:
    image: postgres:11
    ports:
      - 5432:5432
    environment:
      - POSTGRES_USER=docker
      - POSTGRES_PASSWORD=docker
    volumes:
      - db:/var/lib/postgresql/data

  app:
    build: .
    command: bash -c "bundle exec rails s -p 3000 -b '0.0.0.0'"
    entrypoint: ./entrypoint.sh
    volumes:
      - ./:/my_app
    ports:
      - 3000:3000
    environment:
      - DATABASE_USERNAME=docker
      - DATABASE_PASSWORD=docker
      - DATABASE_HOST=db
    depends_on:
      - db

volumes:
  db:
    external: true
```

## Step 3 - Setting up configuration

If you notice in the compose file above, we set the environment variable for `DATABASE_USERNAME` , `DATABASE_PASSWORD`, and `DATABASE_HOST` . Then, update the `config/database.yml` for the default part.

```yaml
...

default: &default
  adapter: postgresql
  encoding: unicode
  pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
  database: <%= ENV.fetch("DATABASE_NAME") { "myapp" } %>
  timeout: <%= ENV.fetch("DATABASE_TIMEOUT") { 5000 } %>
  username: <%= ENV.fetch("DATABASE_USERNAME") { "docker" } %>
  password: <%= ENV.fetch("DATABASE_PASSWORD") { "docker" }%>
  host: <%= ENV.fetch("DATABASE_HOST") { "localhost" } %>
  port: <%= ENV.fetch("DATABASE_PORT") { 5432 } %>

...
```

## Step 4 - Build and Run Application

After setting up file configuration, the next thing we have to do is Build services

Open your terminal and navigate to your project directory, run compose build to build or rebuild the services

```bash
docker compose build
```

It will take some time to download the image from Docker Hub if you haven't ruby image installed.

And then run the application

```bash
docker compose up
```

if you got an error message around database setup things, run the database migration just like usual, the difference is you have to add docker command first

```bash
# Setup database
docker compose run --rm app bundle exec rake db:setup

# Migrate database
docker compose run --rm app bundle exec rake db:migrate
```

To stop the application, you can use Ctrl+C or `docker compose down` when you run application in the background.

## Conclusion

If this is your first time using docker, maybe you think you should spend more time configure all the above things. But, the other thing is you just got new knowledge and when you working with your team, you will have the same environment for your entire team. Sounds great right!

In the next tutorial, you will learn how to create a brand new rails application with Docker. See you in the next one.

Containerizing a Rails Application


## Introduction

One of the advantages to using Go is `Standard Library`, Go has built in library that already included when installing Go on your machine.
There are many libraries you can use to build such as web application, rest api, command line interface (CLI), and many more to just using Standard Library.

Today, I'm going to show you how to Lookup the IP, Nameservers, and CNAME for a particular host.

> I assume you know a basic understanding of Go and setup GOPATH on your machine. Check this link about GOPATH https://github.com/golang/go/wiki/SettingGOPATH

## Build App

We are gonna using Go modules ([https://blog.golang.org/using-go-modules](https://blog.golang.org/using-go-modules)) to create the app.

1. Create directory `go-lookup`
2. Move to the `go-lookup` directory and run `go mod init go-lookup` to initialize the modules

Then create a new file `main.go` inside the root directory. We're gonna use main.go to create the function and act as the main application also.

Here is the inital code inside main.go

```go
package main

import "fmt"

func main() {
	fmt.Println("Hello from APP")
}
```

Build and run the program with `go run main.go`, make sure you already in the directory

```bash
$ go run main.go
Hello from APP
```

As you can see, the program will print `Hello from APP` using `Println` from `fmt` package ([https://golang.org/pkg/fmt/](https://golang.org/pkg/fmt/)).

### 1. Lookup the DNS Records from given domain name

Open `main.go` and remove the `Println` line as before, and now we're going to use [net](https://golang.org/pkg/net/) package to lookup the DNS name. First, create a variable to store the domain name inside the main function

```go
// Define domain name
host := "maful.web.id"
```

Then, use `LookupNS` function from net package

```go
// Lookup the DNS Records from the domain name
ns, err := net.LookupNS(host)
if err != nil {
	panic(err)
}
```

`LookupNS` will return pointer of `NS` array, so that we have to looping the `ns` variable to print the Nameserver. If an error occurs, stop the program immediately by using `panic`

```go
// Looping the Nameserver and ignore the index
for _, v := range ns {
	fmt.Println(v.Host)
}
```

Finally, build and run again. You should see the list of Nameserver for the given domain name, in this case is my domain.

```bash
$ go run main.go
ns1.vercel-dns.com.
ns2.vercel-dns.com.
```

### 2. Lookup the IP addresses

Secondly, we still use the same package to lookup the IP addresses with [LookupIP](https://pkg.go.dev/net#LookupIP) function.

```go
// ....
fmt.Println("Looks up the IP Addresses")
ips, err := net.LookupIP(host)
if err != nil {
	panic(err)
}
for i := range ips {
	fmt.Println(ips[i])
}
```

`LookupIP` will return a slice of bytes, so we just need to to use index to get the IP. Here is the result so far when you build and run the program.

```bash
$ go run main.go
// ...

76.76.21.21
```

`76.76.21.21` is the IP of the domain

### 3. Lookup the CNAME

Lastly, we will use `LookupCNAME` function from net library to get CNAME ([wikipedia](https://en.wikipedia.org/wiki/CNAME_record)).

```go
cname, err := net.LookupCNAME(host)
if err != nil {
	panic(err)
}

fmt.Println(cname)
```

We don't need looping like the previous one, we just print the `cname` directly because `LookupCNAME` returns string. Here is the result

```bash
$ go run main.go
// ...
maful.web.id.
```

## Conclusion

Finally, we have created a simple application using Go. Based on what we code before, we can refactor the code into several functions, but we're not doing in this tutorial.

```go
package main

import (
	"fmt"
	"net"
)

func main() {
	// Define domain name
	host := "maful.web.id"
	fmt.Printf("Domain: %s\n\n", host)

	// Lookup the DNS Records from the domain name
	fmt.Println("Looks up the Nameservers")
	ns, err := net.LookupNS(host)
	if err != nil {
		panic(err)
	}
	// Looping the Nameserver and ignore the index
	for _, v := range ns {
		fmt.Println(v.Host)
	}
	fmt.Println()

	fmt.Println("Looks up the IP Addresses")
	ips, err := net.LookupIP(host)
	if err != nil {
		panic(err)
	}
	for i := range ips {
		fmt.Println(ips[i])
	}
	fmt.Println()

	fmt.Println("Looks up the CNAME")
	cname, err := net.LookupCNAME(host)
	if err != nil {
		panic(err)
	}

	fmt.Println(cname)
}
```

Full result

```bash
$ go run main.go
Domain: maful.web.id

Looks up the Nameservers
ns2.vercel-dns.com.
ns1.vercel-dns.com.

Looks up the IP Addresses
76.76.21.21

Looks up the CNAME
maful.web.id.
```


Looks up the IP, Nameservers, and CNAME using Go


## Introduction

When building API, one of the most important part is authentication. Authentication will be a tricky part if we're not handling it properly. In Rails, we have Devise that can make use easier to manage authentication, in this tutorial I'm gonna show you how to install and configure Devise in Rails API.

> Flexible authentication solution for Rails with Warden. https://github.com/heartcombo/devise

At the time I'm writing this post, Devise has been downloaded over 92 million downloads so that makes one of the best solution for authentication in Ruby world.

## Creating Application

First, create rails api and in this case I will use `postgresql` as a database, you can choose whatever you want

```bash
$ rails new devise-api --api --database=postgresql
```

## Install Devise

Then, let's install devise gem. Open `Gemfile` file and add devise then run `bundle install`

```ruby
....
gem 'devise', '~> 4.7', '>= 4.7.3'
```

Once finish to install the gem, the next step is generate devise in the app. Open the terminal and run

```bash
$ rails generate devise:install
Running via Spring preloader in process 2934
      create  config/initializers/devise.rb
      create  config/locales/devise.en.yml
.....
```

Create user model

```bash
$ rails generate devise User
```

## Configuring Rails

Initalize the database

```bash
$ rails db:create
```

Migrate the database

```bash
$ rails db:migrate
```

Actually, you can check the routing of Devise in the terminal with `rails routes`.

After success install devise, we can verify the installation by doing the register, for this case I'm gonna use [Postman](https://www.postman.com/), before that we should run the server with `rails s` in the terminal, make sure you already in the root directory of project.

```bash
$ rails s
=> Booting Puma
=> Rails 6.1.3 application starting in development
=> Run `bin/rails server --help` for more startup options
Puma starting in single mode...
* Puma version: 5.2.2 (ruby 3.0.0-p0) ("Fettisdagsbulle")
*  Min threads: 5
*  Max threads: 5
*  Environment: development
*          PID: 3351
* Listening on http://127.0.0.1:3000
* Listening on http://[::1]:3000
Use Ctrl-C to stop
```

The default port of rails is 3000, so you can access the local server in [http://localhost:3000/](http://localhost:3000/).

![rails](/assets/devise-rails-api-part1/01.png)

So far, we succeed initializing the Rails API. In the next lesson, we are gonna set up the Devise to only return JSON format.

Devise with Rails API - Part 1


Hi,

It's been a really long time since my last post in 2016. I'm so proud that I starting to write again on this brand new site. FYI, you still can read my old post in [mafulprayogaarnandi.blogspot.com](https://mafulprayogaarnandi.blogspot.com/)

Current plan I will write about tips and tricks, then if I have more time I will write a series tutorial about Data Analyst, Go, TypeScript and Ruby.

Wish me luck! 🙏🏻

Blog

Build REST API with Go Fiber and PlanetScale

Containerizing a Rails Application

Looks up the IP, Nameservers, and CNAME using Go

Devise with Rails API - Part 1

First Post

Open Source

VersaFleet Ruby

ECI Rails

Voluntary Savings App

Flutter Daily

Exchange Rates