No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Implementación de Repositorios y gRPC en Go con PostgreSQL

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.

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

  2. 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
    }
    
  3. 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.

  1. Crear script SQL:

    DROP TABLE IF EXISTS students;
    CREATE TABLE students (
        id VARCHAR(32) PRIMARY KEY,
        name VARCHAR NOT NULL,
        age INTEGER
    );
    
  2. 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.

  1. Instalar las dependencias de gRPC:

    go get google.golang.org/grpc
    
  2. 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!

Aportes 5

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

En lugar de usar un QueryContext tambien se puede usar QueryRowContext y queda un poco mas limpia la funcion sin necesidad de iterar un registro para mapearlo que deberia de ser unico

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

El peor maestro del mundo, para qué habla si lo puedo leer yo mismo?

comandos

go get github.com/lib/pq
go get google.golang.org/grpc

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

Dockerfile

FROM postgres:10.3

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

CMD "posgres"