
## 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

Looks up the IP, Nameservers, and CNAME using Go

Devise with Rails API - Part 1

First Post

Open Source

ECI Rails

VPN Servers

Voluntary Savings App

Exchange Rates