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

Containerizing a Rails Application

Looks up the IP, Nameservers, and CNAME using Go

Devise with Rails API - Part 1

First Post

Open Source

ECI Rails

Flutter Daily

Voluntary Savings App

Exchange Rates