Tutorial Conectar PostgresSQL en Go con GORM
Tags: postgres, go, tutorial, beginners
Published: 2021-01-30 14:59:05

### ¿Que es GORM?
> The fantastic ORM library for Golang, aims to be developer friendly

**[GORM](http://gorm.io/) es un ORM** completo para Golang para Bases de datos relacionales (SQL) con todo lo necesario para interactuar con la base de Datos: **Asociaciones, Hooks, Context, migrations, etc**
### Espera… ¿Que es un ORM? 😅
> Object Relational Mappings / Mapeadores de Objetos Relacionales

Es un modelo de programación que permite **mapear las estructuras de una base de datos relacional** sobre una estructura lógica de entidades… ¿Que 🙃? En palabras simples es una **forma de trabajar con objetos de programación** con los datos y entidades de las Bases de datos relacionales con el propósito de simplificar y acelerar el desarrollo de nuestras aplicaciones

### Bien… ¿Por donde empiezo?
#### Tener Go instalado
Para programar con **Go necesitamos Go (🤪)**, así que en la [pagina oficial de Go](https://golang.org/dl/) descargan la ultima version de go y ejecutan este comando para comprobar la instalación de Go:
```bash
> go version
go version go1.15.6 windows/amd64
```
#### Empezar un proyecto de Go con `go mod`

En la carpeta en la que queremos empezar nuestro proyecto ejecutamos: 
```bash
go mod init github.com/user/project
```
Eso generara un nuevo proyecto de Go y podremos empezar a importar los paquetes necesarios para nuestro proyecto. Para este ejemplo **necesitamos GORM** y el **controlador de nuestra bases de datos**, en este caso PostgreSQL.
```bash
go get github.com/jinzhu/gorm github.com/lib/pq
```
### Ahora vamos a escribir código 😎

1. Creamos 2 archivos: Un `main.go` y `connectDB.go` Dentro de una carpeta `/storage `. Dentro del `main.go`:
```go
package main

import (
  "log"
  "github.com/user/project/storage"
)

func main() {
   log.Println("Start Project")

   DB := storage.ConnectDB()
   defer DB.Close()

   log.Println(DB.RowsAffected)
}
```
Esto nos dara un error, porque todavía no hemos creado la función `ConnectDB()` así que vamos a arreglar eso.

2. Conectarnos a la base de datos: Dentro del archivo `storage/connectDB.go` agregamos los paquetes necesarios:
```go
package storage 

import ( 
  "fmt" 
  "log" 
  "github.com/jinzhu/gorm"  
  //Postgres Driver imported 
  _ "github.com/lib/pq"
)
```
Y creamos nuestra función `ConnectDB()`:
```go
//ConnectDB connect to Postgres DB
func ConnectDB() *gorm.DB {
  var (
   host = "localhost"
   user = "postgres"
   port = 5432
   password = "password"
   name = "db"
 )
 //Connect to DB
 var DB *gorm.DB  
 DB, err = gorm.Open("postgres", fmt.Sprintf("host=%s port=%d 
 user=%s password=%s dbname=%s sslmode=disable", host, portInt, 
 user, password, name))
 ...
}
```
Esta es la parte en que se conecta a la bases de datos. Si no sabes como crear una bases de datos, tengo un tutorial de como crearlas con Docker: [Crear contenedores de bases de Datos en Docker](https://dev.to/marlosrodriguez/crear-contenedores-de-bases-de-datos-en-docker-bdg).

En este código: primero la función retorna `*gorm.DB` que es el cliente GORM con la conexión a nuestra bases de datos. Primero se crean las variables con la información de nuestra bases de datos y finalmente usamos el comando `gorm.Open` con nuestros datos, que si no da ningun error, creara un cliente GORM conectado a nuestra base de datos.

Para finalizar vamos a verificar por errores y retornar el cliente

```go
//ConnectDB connect to Postgres DB
func ConnectDB() *gorm.DB {
...
 //Check for Errors in DB 
 if err != nil {  
  log.Fatalf("Error in connect the DB %v", err)  
  return nil 
 }  
 if err := DB.DB().Ping(); err != nil { 
   log.Fatalln("Error in make ping the DB " + err.Error())  
   return nil 
 }  
 if DB.Error != nil { 
  log.Fatalln("Any Error in connect the DB " + err.Error()) 
  return nil 
 }  
 log.Println("DB connected")  
 return DB
}
```
Verificamos si hubo algún error en la bases de datos y hacemos un `Ping` para asegurar nuestra conexión a la base de datos

## ¡Listo! ¡Ya nos conectamos a nuestra Bases de datos conectada! 😀
Como ultimo punto la información de la base de datos es informacion vital, lo mejor es esconderla y ponerla en las variables de entorno, No es muy dificil y escondera la informacion que no deberias o quieras compartir
Gracias por leer y llegar hasta aquí, espero que haya sido de ayuda