Implementación de Repositorios y gRPC en Go con PostgreSQL

Curso de Go Avanzado: Protobuffers y gRPC

Contenido del curso

Introducción

gRPC

Conclusión

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0011:59

Implementación de Repositorios y gRPC en Go con PostgreSQL

Curso de Go Avanzado: Protobuffers y gRPC

Clase 9 de 22

Clase 9 / 22

Recursos

¿Cómo implementar un servicio de back-end con Go y PostgreSQL?

En este tutorial, exploraremos cómo puedes usar Go y PostgreSQL para construir un servicio de back-end eficiente y escalable. Comenzaremos estructurando nuestro proyecto, definiendo modelos y configurando nuestra base de datos para luego implementar repositorios accesibles mediante gRPC.

¿Qué es un modelo en Go y cómo se define?

Un modelo en Go representa la estructura de los datos que planeamos manipular en nuestra aplicación. En este caso, creamos un modelo para representar a un estudiante.

Primero, debes crear una carpeta llamada models en el directorio raíz del proyecto. Dentro de esa carpeta, crea un archivo models.go donde definirás tus structs. Aquí tienes un ejemplo para un modelo de estudiante:

package models

type Student struct {
    ID   string
    Name string
    Age  int32
}

Nota importante: Es crucial definir correctamente el tipo de dato, como int32, para garantizar la compatibilidad con la base de datos y el lenguaje.

¿Cómo se implementa un repositorio en Go?

En el diseño de patrones, un repositorio actúa como una capa intermedia para el acceso a datos, lo que permite la separación de lógica entre la aplicación y el almacenamiento de los datos.

Crear la carpeta repository: Este será el lugar donde vivirá la lógica de acceso a datos.

Definir la interfaz del repositorio:

package repository

import (
    "context"
    "github.com/tuusuario/proyecto/models"
)

type Repository interface {
    GetStudent(ctx context.Context, id string) (models.Student, error)
    SetStudent(ctx context.Context, student models.Student) error
}

Crear una implementación para PostgreSQL:

Crea un archivo postgres.go dentro de un paquete database:

package database

import (
    "context"
    "database/sql"
    "github.com/tuusuario/proyecto/models"
    _ "github.com/lib/pq" // PostgreSQL driver
)

type PostgresRepository struct {
    db *sql.DB
}

func NewPostgresRepository(url string) (*PostgresRepository, error) {
    db, err := sql.Open("postgres", url)
    if err != nil {
        return nil, err
    }
    return &PostgresRepository{db: db}, nil
}

¿Cómo configurar la base de datos PostgreSQL?

Para configurar y utilizar PostgreSQL, necesitas un script de operaciones SQL que defina tu tabla de estudiantes y un Dockerfile para su contenedor.

Crear script SQL:

DROP TABLE IF EXISTS students;
CREATE TABLE students (
    id VARCHAR(32) PRIMARY KEY,
    name VARCHAR NOT NULL,
    age INTEGER
);

Configurar Dockerfile:

FROM postgres:10.3
COPY op.sql /docker-entrypoint-initdb.d/

¿Cómo usar gRPC para operaciones de cliente-servidor?

El uso de gRPC permite crear servicios escalables y eficientes, esenciales en microservicios y arquitecturas distribuidas.

Instalar las dependencias de gRPC:
```
go get google.golang.org/grpc
```

Implementar las funciones SetStudent y GetStudent en el repositorio:

func (r *PostgresRepository) SetStudent(ctx context.Context, student models.Student) error {
    _, err := r.db.ExecContext(ctx, "INSERT INTO students (id, name, age) VALUES ($1, $2, $3) ON CONFLICT (id) DO UPDATE SET name = $2, age = $3", student.ID, student.Name, student.Age)
    return err
}

func (r *PostgresRepository) GetStudent(ctx context.Context, id string) (models.Student, error) {
    row := r.db.QueryRowContext(ctx, "SELECT id, name, age FROM students WHERE id = $1", id)
    var student models.Student
    err := row.Scan(&student.ID, &student.Name, &student.Age)
    if err != nil {
        return models.Student{}, err
    }
    return student, nil
}

Este proceso te permitirá implementar un servicio gestionado por repositorios y accesible mediante gRPC, promoviendo una estructura limpia y mantenible en tu proyecto. Recuerda que la práctica hace al maestro, ¡así que sigue experimentando y mejorando tus habilidades con Go y PostgreSQL!

Nicolás Sañudo

Hace 4 años

Para no generar spam, voy a crear un "hilo" en este comentario sobre los cambios hechos en la clase:

Nicolás Sañudo

Hace 4 años

Dentro del directorio database/:

-- filename: up.sql
DROP TABLE IF EXISTS students;

CREATE TABLE
    students (
        id VARCHAR(32) PRIMARY KEY,
        name VARCHAR(255) NOT NULL,
        age INTEGER NOT NULL
    )

# filename: Dockerfile
FROM postgres:10.3

COPY up.sql /docker-entrypoint-initdb.d/1.sql

CMD ["postgres"]

/** filename: postgres.go */
package database

import (
	"context"
	"database/sql"
	"log"

	_ "github.com/lib/pq"
	"github.com/neecosanudo/platzi-grpc/models"
)

type PostgresRepository struct {
	db *sql.DB
}

// Constructor
func NewPostgresRepository(url string) (*PostgresRepository, error) {
	db, err := sql.Open("postgres", url)
	if err != nil {
		return nil, err
	}

	return &PostgresRepository{db}, nil
}

func (repo *PostgresRepository) SetStudent(ctx context.Context, student *models.Student) error {
	_, err := repo.db.ExecContext(ctx, "INSERT INTO students (id, name, age) VALUES ($1, $2, $3)", student.Id, student.Name, student.Age)
	return err
}

func (repo *PostgresRepository) GetStudent(ctx context.Context, id string) (*models.Student, error) {
	rows, err := repo.db.QueryContext(ctx, "SELECT id, name, age FROM students WHERE id = $1", id)
	// Cerrar conexión de rows para que no quede consumiendo recursos
	defer func() {
		err := rows.Close()
		if err != nil {
			log.Fatal(err)
		}
	}()

	if err != nil {
		return nil, err
	}

	var student = models.Student{}

	// .Next() debe ejecutarse siempre antes de llamar a .Scan()
	for rows.Next() {
		// .Scan() copia las columnas que vienen de rows y las convierte en las propiedades del struct que indiquemos
		err := rows.Scan(&student.Id, &student.Name, &student.Age)
		if err != nil {
			return nil, err
		}
		return &student, nil
	}
	return &student, nil
}

Nicolás Sañudo

Hace 4 años

Dentro del directorio repository/:

/** filename: repository.go */
package repository

import (
	"context"

	"github.com/neecosanudo/platzi-grpc/models"
)

type Repository interface {
	GetStudent(ctx context.Context, id string) (*models.Student, error)
	SetStudent(ctx context.Context, student *models.Student) error
}

var implementation Repository

func SetRepository(repository Repository) {
	implementation = repository
}

func GetStudent(ctx context.Context, id string) (*models.Student, error) {
	return implementation.GetStudent(ctx, id)
}

func SetStudent(ctx context.Context, student *models.Student) error {
	return implementation.SetStudent(ctx, student)
}

Introducción

Microservicios de alto rendimiento con gRPC y Go

Proyecto gRPC con streaming bidireccional

Qué son los Protocol Buffers y cómo funcionan

Compilar Protobuf a paquete Go con protoc

De monolito a microservicios con gRPC

gRPC

gRPC: qué lo hace más rápido que REST

JSON vs Protobuf: cuándo usar cada uno

Definir un StudentService con proto buffers en Go

Implementación de Repositorios y gRPC en Go con PostgreSQL

Criando o primeiro servidor gRPC em Go

Prueba tu servidor gRPC con Postman

Definiendo el servicio de test en gRPC

Implementando servidor gRPC con PostgreSQL en Go

Client streaming en gRPC con Go

Implementación de Streaming del Servidor con gRPC y Protobufs

Streaming del servidor con gRPC en Go

Streaming bidireccional en gRPC con Go

Prueba de streaming bidireccional con gRPC

Implementando un cliente gRPC en Go

Streaming bidireccional en gRPC con Go

Conclusión

gRPC en el navegador con Envoy

Streaming de Datos con gRPC y Protobufers en Backends

Implementación de Repositorios y gRPC en Go con PostgreSQL

Progreso del curso

Introducción

gRPC

Conclusión

Recursos

Recursos