DEV Community: Marlos Rodriguez

Por que aprender TypeScript - Tutorial en español

Marlos Rodriguez — Fri, 13 Aug 2021 15:49:43 +0000

¿Que es TypeScript? 🤔

Es un lenguaje altamente tipado que compila directamente a Javascript, agregando tipado seguro y todos los beneficios del tipado a la hora de desarrollar, en resumen "Un Javascript con superpoderes para desarrolladores". Como compila directamente a Javascript tiene el mismo rendimiento y compatibilidad completa con el ecosistema de Javascript.

Si a la final es Javascript ¿Por que usarlo? 🤨

Principalmente por el tipado, que al momento de desarrollo evita errores de tipado y crea un código más escalable, mantenible y legible, ademas de agregados como decoradores y mejoras en programación orientada a objetos.

TypeScript es altamente popular, y año con año es más usado y popular, y la gran mayoría lo utiliza felizmente. Las grandes compañías lo utilizan sobre Javascript por ser altamente escalable y es compatible con todos los grandes Frameworks de Javascript (Incluso Google con Angular usa por defecto TS).

Por último es muy fácil de aprender si ya manejas Javascript, TypeScript te sera extremadamente familiar y fácil de aprender, por que no deja de ser "Javascript con algunos pasos extras".

Bien, me convenciste ¿Por donde empiezo? 🤓

TypeScript es un lenguaje que compila a Javascript, por lo que necesitamos el compilador:

npm install -g typescript

Esto instalara globalmente typeScript en nuestra PC, para estar seguros que se instalo ejecutamos en consola:

tsc --version

¿Y ahora como uso el compilador? 🤨

Pues para probarlo necesitas crear código de TypeScript y probarlo, los archivos typeScript tiene la extensión .ts, en una carpeta creamos un archivo hello.ts agregamos esto:

console.log("hello world");

Para compilarlo ejecutamos en consola:

tsc hello.ts

eso generara un archivo hello.js que podemos ejecutar como un archivo de Javascript normal

> node hello.js
hello world

ejecutar este comando puede ser algo incomodo, el compilador tiene una opción de "hot reload", cada vez que hagas un cambio lo compilara a Javascript automaticamente ejecutando:

tsc hello.ts --watch

¿Y donde esta el tipado de TypeScript? 🙃

Ahora que estamos familiarizado con el compilador, vamos a ver las características de TypeScript, empezando con el tipado declarando algunas variables:

//Inferido
let name = "José"

//Directo
let age:number = 23

//Declaración vacia, por defecto al no asignar un valor
//la variable es undefined 
let phone:number

//Tipo any, como su nombre indica es cualquier tipo de valor
const haveCar:any = false

Estas son las principales formas de declarar variables en TypeScript, el tipo que se le asigne no podra ser cambiado y siempre sera el mismo, por ejemplo no queremos que un nombre sea un booleano o un numero, tiene que ser un texto.

En las funciones podemos especificar el tipo de entrada y salida, asegurándonos tener el tipo de dato necesario de entrada y no equivocarnos a devolver información:

//Directo
const GetMagicNumber = (n:number):number => {
    return n * 2;
}

//Retorno inferido
//Infiere que tipo de valor va a regresar la función
//por el dato que tenga el return
const GetAmazingNumber = (n:number) => {
    return n * 4;
}

//Any
//Aceptara cualquier tipo de valor
const GetAnyStuff = (n:any) => {
    return n + 2;
}

Esto es genial pero ¿Si quiero usar un Objeto con varios parámetros?

TypeScript te permite crear tipos e interfaces personalizadas para crear diferentes tipos de objetos:

//Tipo porsonalizado
//Es bastante parecido a un objeto
//asignas el nombre a la izquierda
//y el tipo a la derecha.
//Puede ser cualquier tipo dato
//Inclusive personalizado
type dog = {
    name: string;
    age: number;
    kind: string;
}

//Las interfaces son más usadas en Typescript
//son casi iguales a los tipos
interface cat {
    name: string;
    age: number;
    kind: string;
}

//Al declarar un nuevo objeto se debe
//cumplir con el tipo de datos
const firulai:dog = {
    name: "firulai",
    age: 5,
    kind: "good one"
}

//El mismo comportamiento que el tipo
const garfield:cat = {
    name: "firulai",
    age: 5,
    kind: "god one"
}

Y este tipo personalizado puede ser pasado como cualquier otro como parametro de funcione:

const GetCatName = (cat:cat):string => {
    return cat.name;
}

Esto permite crear objetos fuertemente tipados, con parámetros necesarios para funcionar, dando una mejor experiencia de desarrollo teniendo objetos que sabemos que parámetros recibiremos y evitamos cometer errores de tipado en el código.

Esta verificación solo se hace durante el desarrollo, al momento de compilar a JavaScript no surtirá efecto.

Ademas de estos tipos personalizados, TypeScript proporciona mejoras a las clases respecto a Javascript.

class Bird{
  constructor(name, age, kind) {
    this.name= name;
    this.age= age;
    this.kind = kind;
  }
}

Esta es una clase tipica de Javascript, con 3 parametros necesarios en el constructor. Typescript tiene varias mejoras para las clases, como los campos (Fields):

class Bird{
  snack:string = "cookie";
  speak:boolean = true;
  constructor(name, age, kind) {
    this.name= name;
    this.age= age;
    this.kind = kind;
  }
}

Se le pueden aplicar tipado de manera simple como con las variables, pero algo más interesante es que por defecto son campos "públicos", que pueden ser accedidos desde el objeto una vez creado, que es algo que agrega Typescript, el nivel de acceso de sus campos.

class Bird{
  private snack:string = "cookie";
  private speak:boolean = true;

  //Tambien puedes declarar campos de esta forma
  constructor(private name:string,  private age:number, private kind:string){
    this.name= name;
    this.age= age;
    this.kind = kind;
  }
}

Al agregar private los campos solo pueden ser accedidos en esa clase, también existe protected que lo hace accesible también para subclases. Otro importante es readonly también aplicable a tipos e interfaces, que lo que hace despues de ser asignado el valor solo puede leer el valor.

Estos también pueden usarse para las funciones:

class Bird{
  private snack:string = "cookie";
  private speak:boolean = true;

  //Tambien puedes declarar campos de esta forma
  constructor(private name:string,  private age:number, private kind:string){
    this.name= name;
    this.age= age;
    this.kind = kind;
  }

  //Una funcion privada, normalmente para funciones internas
  private getSnack() {
    return this.snack;
  } 

  getBirdInfo():string {
    return `age: ${this.age}, name: ${this.name}, kind: ${this.kind}, snack: ${this.getSnack()}`
  }
}


 const myBird = new Bird("pedro", 2, "loro") 

 console.log(myBird.getBirdInfo())

Para que veas la diferencia, al compilar a JavaScript, el código se ve asi:

"use strict";
class Bird {
    constructor(name, age, kind) {
        this.name = name;
        this.age = age;
        this.kind = kind;
        this.snack = "cookie";
        this.speak = true;
        this.name = name;
        this.age = age;
        this.kind = kind;
    }
    //Una funcion privada, normalmente para funciones internas
    getSnack() {
        return this.snack;
    }
    getBirdInfo() {
        return `age: ${this.age}, name: ${this.name}, kind: ${this.kind}, snack: ${this.getSnack()}`;
    }
}
const myBird = new Bird("pedro", 2, "loro");
console.log(myBird.getBirdInfo());

El resultado de consola seria:

"age: 2, name: pedro, kind: loro, snack: cookie"

¡Felicidades! Has aprendido lo básico de TypeScript, para seguir aprendiendo recomiendo es que crees un proyecto más grande usando Typescript, aplicar TypeScript a proyectos con Node JS y React, o aprender a usar Nodemon.

Pero sobre todo, no dejes de aprender y experimentar. Nunca pares de aprender.

En un futuro Post cubriré como crear una API con Node JS y TypeScript.

😘 Gracias por leer.

Guía API CRUD con Go y PostgreSQL

Marlos Rodriguez — Mon, 08 Feb 2021 20:35:14 +0000

¿Porque escoger Go para crear una API? 🤔

Go es un lenguaje fantástico creado por Google, fuertemente tipado, fácil de leer y con multi-hilo y asincronismo por defecto.
En este post vamos a crear una API CRUD de lista de Videojuegos (Porque el típico TO DO es muy aburrido 😘) con Go Fiber y GORM con una base de datos PostgreSQL, el proyecto se llamara gamelist.

Requisitos Previos 🛑

Como punto de partido tendremos un proyecto de Go usando Go Modules, tener una instancia de GORM con PostgreSQL y un servidor básico con Fiber. Si no sabes como, en posts anteriores cubro estos temas, combínalos y sigue el tutorial.

Tutorial Conectar PostgresSQL en Go con GORM

Marlos Rodriguez ・ Jan 30 '21

#postgres #go #tutorial #beginners

Guía de Crear una API con Go Fiber de 0

Marlos Rodriguez ・ Jan 30 '21

#go #tutorial #webdev #beginners

La Estructura del Proyecto

Si has seguido los tutoriales previos, tendras dentro de tu proyecto un archivo main.go con un servidor de Fiber y una carpeta con el archivo /storage/connectDB.go con la conexión a la base de datos. Creamos 3 carpetas mas:

handlers: Aquí crearemos las funciones HTTP.
models: Nuestros modelos para la bases de datos.
utils: Y aquí nuestras funciones y herramientas para nuestro proyecto.

¿Que son las variables de Entorno? Y porque tienes que usarlas 🤗

Las Variables de Entorno (O ENV por "Environment variables") son variables de valor dinámico que afectan el funcionamiento de la App. En proyectos de programación es información importante que afecta su funcionamiento y que debería estar oculto al publicarlo (Por ejemplo al subirlo al GitHub), en estos archivos deben estar cosas como los datos de conexión a la base datos.

Para continuar con el proyecto vamos a usar ENV.

Usar ENV en nuestro proyecto 🤫

Para usar ENV agregamos en la ruta base de nuestro proyecto un archivo .env, la sintaxis de los ENV es key=value. Vamos a tomar los datos de nuestra Base de datos, y ponerla en nuestro ENV:

DB_HOST=localhost
DB_USER=postgres
DB_PORT=5432
DB_PASSWORD=password
DB_NAME=db

Los nombres de las variables suelen estar en mayúsculas y separados por "_".

Para acceder a nuestras variables utilizares el paquete os y su función Getenv os.Getenv(key) esta función buscara la variable que le pasemos y si existe retornara el valor.

¡Alto! Importante Esto por si solo no nos servira a nosotros ¿Por que? Porque esto busca en las ENV por defecto de Go, solo con agregar el archivo .env el programa no sabra que existe y no cargara nuestras variables.

Para que nuestra aplicación carga las variables y podamos usarlas, usaremos el paquete GoDotEnv que cargara nuestro archivo .env permitiendo usarlas. lo agregamos con el comando go get:

go get github.com/joho/godotenv

Para usarlo agregamos en el archivo donde usemos las ENV, en los import el paquete GoDotEnv:

import (
    //Autoload the env
    _ "github.com/joho/godotenv/autoload"
)
```


Al importar el `autoload` como su nombre indica solo al importarlo cargara nuestro archivo `.env`. Otra forma de hacerlo, pero que puede darle problemas en el deploy, es:


````go
import (
    "github.com/joho/godotenv"
    "log"
    "os"
)

func main() {
  err := godotenv.Load()
  if err != nil {
    log.Fatal("Error loading .env file")
  }

  val:= os.Getenv("key")
}
```
{% endraw %}


### Implementar ENV y mejores practicas 🤓
Ahora con el paquete [GoDotEnv](https://github.com/joho/godotenv), **podemos usar ENV en todo el proyecto** pero hay ciertas cosas en tener en cuenta.
* Orden de uso: Esto es algo importante, como dije podemos usar GoDotEnv en todo el proyecto, pero el orden es importante, deberías usar este paquete cargar el {% raw %}`.env`{% endraw %} en una etapa temprana del programa, porque puede que intente cargar una variable importante y no lo encuentra.
* Rendimiento: Acceder al ENV es un poco lento, ten esto en cuenta y no abuses de esto.

Para evitar esto, me gusta crear en mis proyecto la utilidad {% raw %}`accessENV.go`{% endraw %} el cual se encargara de acceder a todas nuestras variables y las guardara en una cache para que cuando se necesite otra vez podrá accederse rápidamente.

Creamos el archivo {% raw %}`accessENV.go`{% endraw %} dentro de la carpeta {% raw %}`utils`{% endraw %}, importamos los paquetes {% raw %}`os`{% endraw %} {% raw %}`sync`{% endraw %} y {% raw %}`GoDotEnv`{% endraw %} crearemos una función con el mismo nombre {% raw %}`accessENV`{% endraw %} y fuera de la función crearemos nuestra "cache" que sera un {% raw %}`map`{% endraw %} de Go con un {% raw %}`RWMutex`{% endraw %} del paquete {% raw %}`sync`{% endraw %}, este sera el resultado de la función:
{% raw %}

```go
package utils

import (
    "os"
    "sync"

    //Autoload the env
    _ "github.com/joho/godotenv/autoload"
)

var (
    environment      = map[string]string{}
    environmentMutex = sync.RWMutex{}
)

//AccessENV Return the ENV if exits
func AccessENV(key string) string {
        //Obtiene el valor del map, si existe regresa el valor
    environmentMutex.RLock()
        val := environment[key]
    environmentMutex.RUnlock()

    if environment[key] != "" {
        return val
    }

        //Si el valor no existe, lo obtiene de ENV
    val := os.Getenv(key)

    if val == "" || len(val) <= 0 {
        return ""
    }

        //Si existe en ENV, lo asigna al map
    environmentMutex.Lock()
    environment[key] = val
    environmentMutex.Unlock()

    return val
}
```
{% endraw %}

#### ¿Que es el {% raw %}`RWMutex`{% endraw %} y porque no uso solo el {% raw %}`map`{% endraw %}?
> RWMutex is a reader/writer mutual exclusion lock

Esto quiere decir que bloquea la lectura y escritura de los {% raw %}`map`{% endraw %}, el cual **es necesario si se trabaja con gorutines**, porque puede dar un {% raw %}`fatal error`{% endraw %} debido que si no se bloquea, dos gorutines pueden intentar leer o escribir al mismo tiempo, corrompiendo los datos y deteniendo la aplicación.

La forma es que como funciona es que:
* {% raw %}`Lock`{% endraw %} {% raw %}`Unlock`{% endraw %} para bloquear y desbloquear la **escritura**
* {% raw %}`RLock`{% endraw %} {% raw %}`RUnlock`{% endraw %} para bloquear y desbloquear la **lectura**
El uso de maps es seguro dentro de las funciones y no dará ningún error.

Ahora en podemos usar esto y acceder a nuestras variables de manera segura y rápida. Con nuestra función vamos a cambiar la función de {% raw %}`ConnectDB()`{% endraw %} para acceder a los datos de la base de datos desde el archivo {% raw %}`.env`{% endraw %}, cambiamos el codigo de esta manera:
{% raw %}

```go
package storage 

import ( 
  "fmt" 
  "log" 
  "strconv"
  "github.com/jinzhu/gorm"  
  //Postgres Driver imported 
  _ "github.com/lib/pq"
  "gamelist/utils"
)
func ConnectDB() *gorm.DB {
   var (
        host     = utils.AccessENV("DB_HOST")
        user     = utils.AccessENV("DB_USER")
        port     = utils.AccessENV("DB_PORT")
        password = utils.AccessENV("DB_PASSWORD")
        name     = utils.AccessENV("DB_NAME")
    )
    if host == "" {
        log.Fatalln("Error loading ENV")
        return nil
    }

    portInt, err := strconv.Atoi(port)

    if err != nil {
        log.Fatalln("Error en convertir el port : " + err.Error())
        return nil
    }
}
```
{% endraw %}


El resto del código es igual, ahora comprobamos si las variables están vacías, en cuyo caso ocurrió un **error al obtener los valores de ENV**. Luego se convierte el port de {% raw %}`string`{% endraw %} a {% raw %}`int`{% endraw %}, **formato que la función necesita**.

## Crear el modelo de {% raw %}`Juego`{% endraw %}
Para poder trabajar con [GORM](http://gorm.io/) necesitas crear un modelo. Dentro de la carpeta {% raw %}`models` creamos el archivo `juego.go`, para este proyecto solo usaremos un modelo, el cual sera `Juego` que tendra `Nombre`, `Desarrollador` y `precio`, usaremos el `Model` de GORM que nos provee con **todo lo necesario para manipular la información**:
{% raw %}

```go
package models

import (
    "time"

    "github.com/jinzhu/gorm"
) 

//Juego estructura 
type Juego struct {
        gorm.Model
        Nombre         string `gorm:"not null" json:"nombre"`
        Desarrollador  string `gorm:"not null" json:"desarrollador"`
        Precio         int    `gorm:"not null" json:"precio"`
}
```
{% endraw %}

El {% raw %}`gorm.Model`{% endraw %} nos agrega esto a nuestro {% raw %}`Juego`{% endraw %}:
{% raw %}

```go
// gorm.Model definition
type Model struct {
  ID        uint           `gorm:"primaryKey"`
  CreatedAt time.Time
  UpdatedAt time.Time
  DeletedAt gorm.DeletedAt `gorm:"index"`
}
```
{% endraw %}

Ahorrándonos de agregarlos nosotros, por ultimo agregamos un {% raw %}`Hook`{% endraw %} que nos permite GORM. Este se llamara {% raw %}`AfterUpdate`{% endraw %} que se ejecuta cada que actualizamos algo y la usaremos para actualizar el dato {% raw %}`UpdatedAt`{% endraw %} automáticamente, este es el código:
{% raw %}

```go
// Updating data in same transaction
func (u *User) AfterUpdate(tx *gorm.DB) (err error) {
  u.UpdatedAt = time.Now()
  return
}
```
{% endraw %}

Por ultimo para poder usarlo, tenemos que hacer la migración en la base de datos. Dentro del {% raw %}`ConnectDB()`{% endraw %} antes del {% raw %}`return`{% endraw %} agregamos {% raw %}`DB.AutoMigrate(&models.User{})`{% endraw %} esto hara la migración en la base de datos si no existe, y si existe simplemente la ignorara evitando cualquier tipo de problemas.

## Ya cree el modelo ¿Ahora como lo uso? Creando el CRUD de la DB 👨‍💻
Esto constara de 5 funciones que interactuarán con nuestra base de datos y sera la base de nuestro CRUD. Dentro de la carpeta storage creamos {% raw %}`juegos.go`{% endraw %} donde crearemos nuestro CRUD.

importaremos estos paquetes:
{% raw %}

```go

import (
    "log"
    "time"
    "github.com/jinzhu/gorm"

    "gamelist/models"
)
```
{% endraw %}

Existe diferentes maneras de trabajar con la instancia de la base de datos, en este tutorial crearemos una estructura con la base de datos y agregaremos los métodos de nuestro CRUD.
{% raw %}


```go
//JuegoDB struct
type JuegoDB struct {
    db  *gorm.DB
}
```
{% endraw %}


esto creara una estructura con una instancia de GORM como parámetro, podremos crear tantas como queramos, importante que nombre de la instancia de GORM este en minuscula y asi no se exporte. Para poder usarlo tenemos que crear una nueva con una instancia de GORM conectada a nuestra base de datos, para ellos crearemos una función que la cree:
{% raw %}

```go
//NuevoJuegoDB Create a new storage user service
func NuevoJuegoDB () JuegoDB {
        nuevaDB := ConnectDB()
    nuevoServicio := JuegoDB{db: nuevaDB}

    return nuevoServicio 
}
```
{% endraw %}

Esto creara una nueva instancia y sera lo que usemos después en nuestros handlers. Como estamos en la misma carpeta que la función {% raw %}`ConnectDB()`{% endraw %} podremos usarla sin necesidad de ninguna importación.

### Crear los métodos del CRUD
Ahora que podemos crear una nueva instancia {% raw %}`JuegoDB`{% endraw %} necesitamos agregar los métodos a nuestra estructura, esto hara que al crear una nueva instancia en {% raw %}`NuevoJuegoDB()`{% endraw %} venga con funciones que podremos usar, para agregarlo como metodo tenemos que crear una función normal pero con {% raw %}`(j *JuegoDB)`{% endraw %} antes del nombre, así que vamos a hacerlo.

* **Obtener un juego**:
{% raw %}

```go
//ObtenerJuego del juego con el ID
func (j *JuegoDB) ObtenerJuego(id int) *models.Juego, error {
        var juego *models.Juego = new(models.Juego)     
        // SELECT * FROM juegos WHERE id = 10;
        if err := j.db.First(&juego, id).Error; err != nil {
        return nil, err
    }

        return juego, nil
}
```
{% endraw %}

Esta función da por hecho que el {% raw %}`id`{% endraw %} existe y no esta vacío, comprobaremos el id en los handlers. Esta función crea una variable vacia, que se usara en la DB, GORM buscara automaticamente en función del modelo de la variable y le pasaremos el {% raw %}`id`{% endraw %} como parametro. En caso de error regresara un {% raw %}`nil`{% endraw %} y el error, si todo salio bien, regresara el {% raw %}`juego`{% endraw %} y un error {% raw %}`nil`{% endraw %}.

* **Obtener todos los Juegos**:
{% raw %}

```go
//ObtenerJuegos Obtener todos los Juegos
func (j *JuegoDB) ObtenerJuegos () []*models.Juego, error {
        var juego []*models.Juego = []*models.Juego{new(models.Juego)     
        // SELECT * FROM juegos;
        if err := j.db.Find(&juego).Error; err != nil {
        return nil, err
    }

        return juego, nil
}
```
{% endraw %}


* **Crear un Juego**:
{% raw %}

```go
//CrearJuego crea un Juego
func (j *JuegoDB) CrearJuego(nuevoJuego *models.Juego) *models.Juego, bool, error {
        if err := j.db.Create(&nuevoJuego).Error; err != nil {
        return nil, false, err
    }

        return *nuevoJuego, true, nil
}
```
{% endraw %}


* **Modificar un Juego**:
{% raw %}

```go
//ModificarJuego Modifica el Juego
func (j *JuegoDB) ModificarJuego(nuevoJuego *models.Juego) bool, error {
        if err := j.db.Model(&juego).Updates(&nuevoJuego).Error; err != nil {
        return false, err
    }

        return true, nil
}
```
{% endraw %}

En esta función se utiliza {% raw %}`Updates`{% endraw %} que actualiza todos los campos que no estén vacíos. GORM, encadena las funciones, al agregar {% raw %}`Model()`{% endraw %} le decimos donde buscar, luego la función {% raw %}`Updates`{% endraw %} buscara con el {% raw %}`id`{% endraw %} del objeto y actualizara en la base de datos.

* **Eliminar un Juego**:
{% raw %}

```go
//EliminarJuego Elimina un Juego
func (j *JuegoDB) EliminarJuego(id int) bool, error {
        if err := j.db.Delete(&nuevoJuego, id).Error; err != nil {
        return false, err
    }

        return true, nil
}
```
{% endraw %}


Estas son todas las funciones de nuestro CRUD, **Podremos acceder a los juegos, crearlo, modificarlo y eliminarlo**.

## Ahora con las funciones de la DB, Los Handlers 😎

Como ya dije, usaremos [Go Fiber](https://gofiber.io/) para nuestros Handlers y administrar las peticiones HTTP. Usaremos la misma estructura que las funciones de la Base de datos. Crearemos una estructura y le agregaremos las funciones de nuestro handler.
{% raw %}

```go
import (
     "strconv"
     "strings"
     "time"

      "github.com/go-redis/redis/v8"
      "github.com/gofiber/fiber/v2"
      "github.com/jinzhu/gorm"

      "gamelist/storage"
      "gamelist/models"
)

type juegosHandler struct {
     BaseDatos storage.JuegoDB
}
```
{% endraw %}


Y crearemos la función para crear un nuevo handler:
{% raw %}

```go
//NuevoJuegosHandler Crear un nuevo handler
func NuevoJuegosHandler() *juegosHandler {
    //Regresa nuevo Handler
    return &juegosHandler{
        BaseDatos: storage.NuevoJuegoDB(),
    }
}
```
{% endraw %}

Ahora crearemos nuestros handlers usando [Go Fiber](https://gofiber.io/), la forma de un handler de Fiber es: `func Nombre(c *fiber.Ctx) error {...}`, son todas las mismas, toma como metodo el `Context` o contexto de Fiber y regresa un `error` si todo sale bien sera `nil`. Ahora vamos a crear nuestras funciones:

* **Obtener un Juego por ID**:
{% raw %}

```go
//ObtenerJuego Obtener un Juego por ID
func (j *juegosHandler) ObtenerJuego(c *fiber.Ctx) error {
        //Obtener el ID desde los parametros, es uno de los metodos de Fiber
    ID := c.Params("id")

        //Si el ID esta vacio, no se envio asi que regresa un error
    if len(ID) < 0 {
                //Esta es la forma de regresar errores en fiber
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Review your input"})
    }
        ...
}
```
{% endraw %}

Para enviar errores en Fiber tienes que enviar un numero de {% raw %}`Status`{% endraw %} o Estatus, que indique que ha pasado con la petición, Fiber viene con codigos por defecto que son los estandares en la Web. Y opcionalmente **puedes mandar información en formato JSON** con la información del servidor, en este caso el error. Ahora convertiremos el ID, que es un {% raw %}`string`{% endraw %} a un {% raw %}`int`{% endraw %} para ser usado en la Base de datos:
{% raw %}

```go
//ObtenerJuego Obtener un Juego por ID
func (j *juegosHandler) ObtenerJuego(c *fiber.Ctx) error {
        ...
        //Convertir ID a int
        IntID, err := strconv.Atoi(ID)

    if err != nil {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error converting in Integer", "data": err.Error()})
    }
        //Obtener datos del Juego
    juego, err := j.BaseDatos.ObtenerJuego(ID)

    if err != nil {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error in DB", "data": err.Error()})
    }

        //Regresar los datos del juego, Go lo convertira en JSON
    return c.Status(fiber.StatusAccepted).JSON(juego)
}
```
{% endraw %}

* **Obtener todos los juegos**: Esta es mas simple que el anterior, no tenemos que hacer ninguna comprobación por parte del usuario, solo asegurarnos de obtener la lista de Juegos.
{% raw %}

```go
//ObtenerTodosJuegos Obtener Todos los Juegos
func (j *juegosHandler) ObtenerTodosJuegos(c *fiber.Ctx) error {
        //Obtener datos del Juego
    juego, err := j.BaseDatos.ObtenerJuego(ID)

    if err != nil {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error in DB", "data": err.Error()})
    }

        //Regresar los datos del juego, Go lo convertira en JSON
    return c.Status(fiber.StatusAccepted).JSON(juego)
}
```
{% endraw %}

Al igual que con el anterior, Go lo convertira en JSON automáticamente, no importa si es un array.

* **Crear un Juego**:
{% raw %}

```go
//CrearJuego Crea un nuevo Juego
func (j *juegosHandler) CrearJuego(c *fiber.Ctx) error {
        //Crear el nuevo juego
    var nuevoJuego *models.Juego

        //Obtener los datos del body
        if err := c.BodyParser(&nuevoJuego); err != nil {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Revisa tu Body", "data": err.Error()})
    }

        //Comprobar los datos del juego
        //Nombre
    if len(strings.TrimSpace(nuevoJuego.Nombre)) <= 0 || strings.TrimSpace(nuevoJuego.Nombre) == "" {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "El Nombre del juego es obligatorio")
    }

        //Desarrollador
    if len(strings.TrimSpace(nuevoJuego.Desarrollador)) <= 0 || strings.TrimSpace(nuevoJuego.Desarrollador) == "" {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "El Desarrolladordel juego es obligatorio")
    }

        //Precio
    if len(nuevoJuego.Precio) < 0 {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "El precio no puede ser negativo")
    }

        //Crear el Juego
    juego, exitoso, err := j.BaseDatos.CrearJuego(nuevoJuego)

    if err != nil || !exitoso {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error in DB", "data": err.Error()})
    }

        //Regresar los datos del juego, Go lo convertira en JSON
    return c.Status(fiber.StatusAccepted).JSON(juego)
}
```
{% endraw %}

En esta función obtendremos los datos del nuevo juego del {% raw %}`body`{% endraw %} con los datos que el usuario deberia enviar, tendra que enviar un {% raw %}`JSON`{% endraw %} como este:
{% raw %}

```json
{
        "nobmre": "Dark Souls",
        "desarrollador": "From Software",
        "precio": 20
}
```
{% endraw %}


* **Modificar un Juego**: Esta sera muy similar al anterior pero verificaremos los valores y si no lo envia lo tendra vacio y asi GORM lo ignorara:
{% raw %}


```go
//ModificarJuego Modificia un Juego
func (j *juegosHandler) ModificarJuego (c *fiber.Ctx) error {
        //Crear el nuevo juego
    var body *models.Juego

        //Obtener los datos del body
        if err := c.BodyParser(&body); err != nil {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Revisa tu Body", "data": err.Error()})
    }

        //Crear el nuevo juego
    var nuevoJuego *models.Juego

        //Comprobar los datos del juego
        //Nombre
    if len(strings.TrimSpace(body.Nombre)) <= 0 || strings.TrimSpace(body.Nombre) == "" {
        nuevoJuego.Nombre = body.Nombre
    }

        //Desarrollador
    if len(strings.TrimSpace(body.Desarrollador)) <= 0 || strings.TrimSpace(body.Desarrollador) == "" {
        nuevoJuego.Desarrollador= body.Desarrollador
    }

        //Precio
    if len(body.Precio) < 0 {
        nuevoJuego.Precio= body.Precio
    }

        //Modificar el Juego
    exitoso, err := j.BaseDatos.ModificarJuego(nuevoJuego)

    if err != nil || !exitoso {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error in DB", "data": err.Error()})
    }

        //Esto regresara el numero de estatus de que todo salio bien
    return c.SendStatus(fiber.StatusAccepted)
}
```
{% endraw %}


* **Eliminar un Juego**:
{% raw %}

```go
//EliminarJuego Elimina un Juego por ID
func (j *juegosHandler) EliminarJuego(c *fiber.Ctx) error {
        //Obtener el ID desde los parametros, es uno de los metodos de Fiber
    ID := c.Params("id")

        //Si el ID esta vacio, no se envio asi que regresa un error
    if len(ID) < 0 {
                //Esta es la forma de regresar errores en fiber
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Review your input"})
    }

        //Convertir ID a int
        IntID, err := strconv.Atoi(ID)

    if err != nil {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error converting in Integer", "data": err.Error()})
    }
        //Obtener datos del Juego
    exitoso, err := j.BaseDatos.EliminarJuego(ID)

    if err != nil || !exitoso {
        return c.Status(fiber.ErrBadRequest.Code).JSON(fiber.Map{"status": "error", "message": "Error in DB", "data": err.Error()})
    }

        //Regresar Estatus de aceptado, todo salio bien.
    return c.SendStatus(fiber.StatusAccepted)
}
```
{% endraw %}


Con esto terminamos con el handler de nuestro CRUD, Lo unico que falta es configurar el servidor con los metodos necesarios.

## Configurar el Servidor Fiber

En nuestro {% raw %}`main.go`{% endraw %} deberiamos tener algo como esto:
{% raw %}

```go
func main() {
    //Crear nuestra aplicación de Fiber
    app := fiber.New()

    app.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Hello, World 👋!")
    })

    log.Fatal(app.Listen(":3000"))
}
```
{% endraw %}

Para poder configurar con nuestros handlers, tendremos que agregar esto a nuestros {% raw %}`import`{% endraw %}
{% raw %}

```go
import (
      "log"

      "github.com/gofiber/fiber/v2"

      "gamelist/handlers"
)
```
{% endraw %}


Ahora crearemos un nuevo {% raw %}`Handler`{% endraw %} y agregaremos las rutas de nuestro CRUD:
{% raw %}


```go
func main() {
    //Crear nuestra aplicación de Fiber
    app := fiber.New()

    nuevoHandler := handlers.NuevoJuegosHandler()

    app.Get("/:id", nuevoHandler.ObtenerJuego)
    app.Get("/", nuevoHandler.ObtenerTodosJuegos)
    app.Post("/", nuevoHandler.CrearJuego)
    app.Put("/", nuevoHandler.ModificarJuego)
    app.Delete("/:id", nuevoHandler.EliminarJuego)

    log.Fatal(app.Listen(":3000"))
}
```
{% endraw %}


### ¡Listo! ¡Terminamos nuestro Proyecto! 🤩

Eso es todo en este tutorial, Los siguientes pasos serian agregar {% raw %}`middlewares`{% endraw %} a nuestro proyecto y seguridad con {% raw %}`JWT`{% endraw %}.

Gracias por leer, cualquier cosa no dudes en preguntar.

Guía de Crear una API con Go Fiber de 0

Marlos Rodriguez — Sat, 30 Jan 2021 16:15:48 +0000

¿Porque escoger Go para crear una API?

Go es un lenguaje pensado para la web por Google y se caracteriza por:

lenguaje rápido: por ser compilado y tener poca locación de memoria.
Fuertemente tipado: facilitando la creación de código limpio y fácil de leer.
Eficiente para crear servidores y aplicaciones web: Es un leguaje pensado para la web preparado con multi-hilo y asincronismo.

Por lo que es perfecto para crear API rápidamente y con un buen rendimiento.

¿Que es Fiber y porque debería usarlo?

Fiber es un framework web inspirado en Express construido sobre Fasthttp, el motor HTTP más rápido para Go. Diseñado para facilitar las cosas para un desarrollo rápido con cero asignación de memoria y rendimiento en mente.

Existen varios Frameworks de Go, pero entre todos Fiber es mi favorito, bastante sencillo de usar y con gran rendimiento, sirve tanto para un proyecto pequeño como para uno grande. Es ideal para comenzar con Go, tiene una buena documentación, y en caso de necesitar ayuda tiene un servidor de Discord muy activo (En ingles 😎).

¿Bien, Como empiezo?

Primero que nada necesitas Go para trabajar con Go (🤪) así que hay que descargarlo en la pagina oficial de Go, descargan la version mas nueva de Go, una vez instalado ejecutan este comando:

> go version
go version go1.15.6 windows/amd64

¡Genial! ¡Ya tenemos Go instalado!

¡Ahora necesitamos crear nuestro gran proyecto! Vamos a usar “Go Modules” para crear un proyecto en cualquier carpeta, ejecutamos este comando:

> go mod init asombrosoProyecto
go: creating new go.mod: module asombrosoProyecto

creara un nuevo proyecto en la carpeta con el nombre asombrosoProyecto, puedes cambiarlo por lo que quieras, y sera la ruta base de nuestro proyecto. Además notaras el archivo go.mod el cual fue creado y nos dice el nombre del proyecto, la version de Go y las dependencias que tenemos, que de momento no tenemos ninguna.
¿Que necesitamos para crear una API con Fiber? Pues Fiber ¿no? 🤣
Para instalar un ejecutamos el comando go get seguido del nombre del paquete, para instalar fiber ejecutamos:

> go get github.com/gofiber/fiber/v2
go: downloading github.com/gofiber/fiber/v2 v2.3.3

Esto agregara fiber como dependencia a nuestro go.mod , en este punto debería verse así:

module asombrosoProyecto

go 1.15

require github.com/gofiber/fiber/v2 v2.3.3

Tambien habrá creado un go.sum el cual se encargará de gestionar nuestras versiones e indicar el hash de integridad de cada una de ellas, permitiendo trabajar con las dependencias.

¡Listo! ¡Ya tenemos todo lo necesario para empezar a escribir código! 🤩

Escribir el código de nuestra API

Creamos un archivo main.go y abrimos nuestro editor de código de preferencia, agregamos log y fiber a nuestro programa:

package main

import (
    "log"

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

esto importara log y fiber para ser usado en nuestro código, en nuestra función main agregamos este código:

func main() {
    //Crear nuestra aplicación de Fiber
    app := fiber.New()
    /*Esto creara una petición GET en la ruta base
    Regresara un simple string 
    Primero se agrega un string que sera el path de la ruta 
    y luego se agrega la funcion handler, el cual tiene
    siempre esa forma*/
    app.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Hello, World 👋!")
    })
    /*Se ejecuta el servidor y en caso de fallar mostrara
    log.Fatal con el error*/
    log.Fatal(app.Listen(":3000"))
}

Ahora para ejecutar el servidor, ejecutamos go run main.go pero primero, para evitar errores con las dependencias, ejecutamos:

go mod tidy

Esto para garantizar que los módulos de los que depende tu proyecto no cambien inesperadamente, ya sea por razones maliciosas, accidentales o de otro tipo.

Ahora si, ejecuta:

go run main.go

Y deberían ver algo como esto:

¡Felicidades! ¡Tienes tu primera API con Go Fiber! visita localhost:3000 en tu navegador y deberías ver:

Para seguir aprendiendo te recomiendo que mires:

Fiber Recipes: Un conjunto de ejemplos creados con fiber, diferentes bases de datos, tecnologías o testing.
Fiber Docs: La documentación tiene todo lo que necesitas para crear una aplicación, pequeña o grande.

Pero sobre todo, no dejes de aprender y exprimentar. Nunca pares de aprender.
En un futuro Post cubriré como crear un CRUD e integrarlo con PostgreSQL 😘 Gracias por leer.

Guía API CRUD con Go y PostgreSQL

Marlos Rodriguez ・ Feb 8 '21

#tutorial #go #postgres #beginners

Tutorial Conectar PostgresSQL en Go con GORM

Marlos Rodriguez — Sat, 30 Jan 2021 14:59:05 +0000

¿Que es GORM?

The fantastic ORM library for Golang, aims to be developer friendly

GORM 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 descargan la ultima version de go y ejecutan este comando para comprobar la instalación de Go:

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

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.

go get github.com/jinzhu/gorm github.com/lib/pq

Ahora vamos a escribir código 😎

Creamos 2 archivos: Un main.go y connectDB.go Dentro de una carpeta /storage. Dentro del main.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.

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

package storage 

import ( 
  "fmt" 
  "log" 
  "github.com/jinzhu/gorm"  
  //Postgres Driver imported 
  _ "github.com/lib/pq"
)

Y creamos nuestra función ConnectDB():

//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.

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

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

Crear contenedores de bases de Datos en Docker

Marlos Rodriguez — Sat, 30 Jan 2021 14:04:23 +0000

¿Por que usar Docker? 🤔

Docker es una incredible herramienta que todo programador Web debería conocer. Docker viene de los problemas de crear, ejecutar, probar y mover las aplicaciones, con problemas como librerías, dependencias o configuraciones de sistema, problemas que todo programador habrá tenido.
Docker viene a solucionar con los contenedores al aislar los programas con todo lo que necesita para ejecutarse y asegurando que en toda situación va a ejecutarse no importa el sistema o entorno.

¿No es lo mismo que una maquina virtual? 🤨

No, Docker es diferente al funcionamiento a una maquina virtual, como su nombre dice es una maquina completa emulada, por lo cual emula absolutamente todo, incluyendo el sistema operativo, el kernel y programas pre-instalados del sistema, lo que puede resultar en una varios GB de peso.
Docker por su parte solo toma las dependencias y librerías necesarias para que el programa se ejecute, aísla el programa en contenedores y permite ejecutarlo sobre el motor de docker que asegura que funcionara en cualquier lugar.

¿Y esto en que se relaciona con las Bases de Datos? 😓

Docker puede usarse para ejecutar cualquier pieza de software de manera rápida y segura, eso incluye los motores de bases de datos. Esto es uno de los usos mas comunes de Docker, en vez de instalar la bases de datos en nuestro sistema y hacer la configuración manualmente, podemos usar las imágenes de docker, que son muy populares y crear una base de datos rápidamente.

¿Que es una imagen en Docker?

Las imágenes Docker son plantillas (que incluyen una aplicación, los binarios y las librerías necesarias) que se utilizan para construir contenedores Docker y ejecutarlos. Si has trabajado con lenguajes orientados a objetos, son como (valga la redundancia) objetos, una base y estructura para crear una nueva aplicación con características ya establecidas. Puedes ver todas las imágenes en Docker Hub.

Espera, dijiste que la aplicación se “aísla” ¿Como accedo a la bases de datos? 🙃

Si, eso dije y no estaba equivocado en eso. Es una de las maravillas de Docker, entre sus características esta la de permitir exponer un puerto de tu aplicación al resto de tu equipo. La forma en que funciona docker es que tiene su propia red interna, aislada del resto del equipo, tiene la opción de exponer esos puertos “como un espejo” ¿A que me refiero con “espejo”? es que se asigna un puerto de la computadora a uno de la red de docker. Esta imagen lo deja mas claro:

Bueno, me convenciste ¿Como creo una base de datos? 😅

¿Que se necesita para ejecutar una imagen en docker? obviamente Docker, vamos a la pagina oficial de docker y descargar Docker Desktop: Para Windows y Mac es un simple instalador, se descarga y ejecuta. Para linux tiene algunos pasos extra, tendras que buscar una version para tu distribución de linux (aunque si estas en linux de seguro sabes mas que yo 😉)
Ahora para asegurarnos de que docker esta instalado ejecutamos en la linea de comando:



$docker -v
Docker version 19.03.13, build 4484c46d9d

Ya tengo Docker ¿Como creo una base de datos?

Bueno, para este ejemplo, vamos a usar dos motores de bases de datos PostgresSQL y MongoDB. Para otros motores de bases de datos el procedimiento es el mismo.

Crear un contenedor de PostgreSQL

Para este y cualquier imagen de Docker vamos a usar como base la pagina de docker hub, en este caso la de Postgres. Abrimos una terminal de comandos y escribimos el siguiente código:



docker run --name tu-nombre -p 5432:5432 -e POSTGRES_PASSWORD=micontraseña -d postgres

docker run: Comando de Docker para crear un contenedor.
--name:Parámetro del nombre, seguido poner el nombre que desees del contenedor.
-p:este es importante, este parámetro asigna los puertos para que pueda accederse desde el equipo. el puerto 5432 (el puerto 5432 es el puerto por defecto de Postgres)del equipo estará escuchando y las mandara a Docker.
-e: Este parámetro significa “environment”, y crea POSTGRES_PASSWORD con la contraseña que se pase como parámetro.
-d: Significa “Detached” y crea el contenedor de manera separada
postgres: Y postgres hace referencia a la imagen de PostgreSQL, que usa como base de nuestra nueva imagen

¡Listo! tenemos una base de datos postgresSQL 😁

El comando debería ejecutar el contenedor después de crearlo, pero si no ejecuta este comando en la terminal:



docker start nombre

Esto ejecutara el contenedor y iniciara la DB. Para detenerla es muy similar:



docker stop nombre

Crear un contenedor de MongoDB

Es muy similar al anterior con una pequeña diferencia, los conceptos generales de docker se aplican igual. Se ejecuta en la terminal:



docker run --name tu-nombre -p 27017:27017 -d mongo

¡Listo! ahora tenemos una base de Datos de MongoDB.

Espera ¿Ahora como uso las bases de datos?

Si quieres conectarte a la base de datos solo tienes que conectarte a localhost:puerto_de_DB y podrás usarla como cualquier otra base de datos, pero ¿Y si quiero manipular los datos por consola? buena pregunta, porque ahora la bases de datos están ejecutándose en Docker, para acceder a ellas tienes que hacerlo mediante un comando de docker llamado docker exec.

En postgres el comando es:



docker exec -it tu-contenedor psql -U postgres

esto se conectara a la base de datos Postgres y ejecutara psql -U postgres, permitiendo interactuar con nuestra base de datos PostgreSQL.

Y en mongo el comando es:



docker exec -it tu-contenedor mongo
```

Muchas gracias por leer, algún problema no duden en escribir un comentario 😁

DEV Community: Marlos Rodriguez

Por que aprender TypeScript - Tutorial en español

¿Que es TypeScript? 🤔

Si a la final es Javascript ¿Por que usarlo? 🤨

Bien, me convenciste ¿Por donde empiezo? 🤓

¿Y ahora como uso el compilador? 🤨

¿Y donde esta el tipado de TypeScript? 🙃

Esto es genial pero ¿Si quiero usar un Objeto con varios parámetros?

Guía API CRUD con Go y PostgreSQL

¿Porque escoger Go para crear una API? 🤔

Requisitos Previos 🛑

Tutorial Conectar PostgresSQL en Go con GORM

Marlos Rodriguez ・ Jan 30 '21

Guía de Crear una API con Go Fiber de 0

Marlos Rodriguez ・ Jan 30 '21

La Estructura del Proyecto

¿Que son las variables de Entorno? Y porque tienes que usarlas 🤗

Usar ENV en nuestro proyecto 🤫

Guía de Crear una API con Go Fiber de 0

¿Porque escoger Go para crear una API?

¿Que es Fiber y porque debería usarlo?

¿Bien, Como empiezo?

Escribir el código de nuestra API

Guía API CRUD con Go y PostgreSQL

Marlos Rodriguez ・ Feb 8 '21

Tutorial Conectar PostgresSQL en Go con GORM

¿Que es GORM?

Espera… ¿Que es un ORM? 😅

Bien… ¿Por donde empiezo?

Tener Go instalado

Empezar un proyecto de Go con go mod

Ahora vamos a escribir código 😎

¡Listo! ¡Ya nos conectamos a nuestra Bases de datos conectada! 😀

Crear contenedores de bases de Datos en Docker

¿Por que usar Docker? 🤔

¿No es lo mismo que una maquina virtual? 🤨

¿Y esto en que se relaciona con las Bases de Datos? 😓

¿Que es una imagen en Docker?

Espera, dijiste que la aplicación se “aísla” ¿Como accedo a la bases de datos? 🙃

Bueno, me convenciste ¿Como creo una base de datos? 😅

Ya tengo Docker ¿Como creo una base de datos?

Crear un contenedor de PostgreSQL

Crear un contenedor de MongoDB

Espera ¿Ahora como uso las bases de datos?

Empezar un proyecto de Go con `go mod`