Muy bien, ya tenemos nuestra API Go en funcionamiento, pero ya es hora de que le demos algo de memoria a largo plazo. Esta semana, conectaremos nuestra API a PostgreSQL, para que pueda almacenar todos esos datos valiosos sin perderlos en el momento en que cierre su aplicación. Créeme, tus usuarios te lo agradecerán.

¿Por qué PostgreSQL?

PostgreSQL o “Postgres” para abreviar, es el verdadero negocio cuando se trata de bases de datos. He aquí por qué es la base de datos más popular:

1. Repleto de funciones: Ya sea que desee almacenar texto antiguo sin formato, JSON o incluso datos geográficos complejos, Postgres lo tiene cubierto. También cumple totalmente con ACID (léase: mantiene sus datos consistentes y seguros) y suficientes opciones de consulta sofisticadas para hacer sonreír a cualquier nerd de los datos.

2. Código abierto y gratuito: Así es, Postgres es totalmente gratuito y de código abierto. Además, cuenta con una comunidad activa que lo mejora constantemente, por lo que nunca tendrás que preocuparte de que quede obsoleto.

3. Escale como un profesional: ya sea que esté creando una aplicación pequeña o un servicio empresarial masivo que consume datos, Postgres puede manejarlo. Está diseñado para escalar, con ejecución de consultas paralelas y magia de optimización para que todo funcione sin problemas.

4. Construido como un tanque: Con décadas de desarrollo en su haber, Postgres es sólido como una roca. Recibe actualizaciones periódicas, tiene un montón de funciones de seguridad y lo utilizan en producción gigantes como Apple y Netflix.

¿Tienes todo eso? Genial, ¡conectémoslo a nuestra API Go y comencemos a hacer magia en la base de datos!

Paso 0: configurar PostgreSQL

Si aún no tienes PostgreSQL instalado, consíguelo aquí. Entonces encendámoslo:

1. Conectarse a PostgreSQL:

   psql -U postgres

1. Crear una base de datos:

   CREATE DATABASE bookdb;

1. Montar una mesa para nuestros libros:

   \c bookdb;
   CREATE TABLE books (
       id SERIAL PRIMARY KEY,
       title VARCHAR(255) NOT NULL,
       author VARCHAR(255) NOT NULL
   );

Ahora tienes una base de datos nueva lista para usar. ¡Es hora de empezar! ¡Ve a hablar con él!

Paso 1: Conéctese Vaya a PostgreSQL

Estamos usando la biblioteca pgx para este. Es rápido, liviano y hace el trabajo.

go get github.com/jackc/pgx/v5

Abra su archivo main.go y agregue este código para configurar una conexión a la base de datos:

var db *pgxpool.Pool

func connectDB() *pgxpool.Pool {
    url := "postgres://postgres:yourpassword@localhost:5432/bookdb"
    config, err := pgxpool.ParseConfig(url)
    if err != nil {
        log.Fatalf("Unable to parse DB config: %v\n", err)
    }

    dbpool, err := pgxpool.NewWithConfig(context.Background(), config)
    if err != nil {
        log.Fatalf("Unable to connect to database: %v\n", err)
    }

    return dbpool
}

Reemplace su contraseña con su contraseña de PostgreSQL. Esta función se conecta a nuestra base de datos bookdb y devuelve un grupo de conexiones, lo que básicamente significa que nuestra aplicación tendrá un montón de conexiones reutilizables listas para funcionar. ¡Eficiencia, cariño! ?

Paso 2: actualice la función principal

Asegurémonos de que nuestra conexión a la base de datos se active cuando lo haga nuestro servidor:

func main() {
    db = connectDB()
    defer db.Close()

    // Initialize router and define routes here (as before)
}

Paso 3: Operaciones CRUD: incorporación de los datos

Muy bien, agreguemos algunas funciones para buscar, crear y administrar libros en nuestra base de datos.

Obtener todos los libros

func getBooks(w http.ResponseWriter, r *http.Request) {
    rows, err := db.Query(context.Background(), "SELECT id, title, author FROM books")
    if err != nil {
        http.Error(w, "Database error", http.StatusInternalServerError)
        return
    }
    defer rows.Close()

    var books []Book
    for rows.Next() {
        var book Book
        err := rows.Scan(&book.ID, &book.Title, &book.Author)
        if err != nil {
            http.Error(w, "Error scanning row", http.StatusInternalServerError)
            return
        }
        books = append(books, book)
    }

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(books)
}

Agregar un libro nuevo

func createBook(w http.ResponseWriter, r *http.Request) {
    var book Book
    err := json.NewDecoder(r.Body).Decode(&book)
    if err != nil {
        http.Error(w, "Bad request", http.StatusBadRequest)
        return
    }

    _, err = db.Exec(context.Background(), "INSERT INTO books (title, author) VALUES ($1, $2)", book.Title, book.Author)
    if err != nil {
        http.Error(w, "Error inserting book", http.StatusInternalServerError)
        return
    }

    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(book)
}

Paso 4: Proteger las rutas con middleware

Queremos asegurarnos de que solo los usuarios autenticados puedan acceder a nuestros nuevos puntos finales basados ​​en bases de datos. Utilice el middleware de autenticación de la Semana 2 y ¡listo!

func main() {
    db = connectDB()
    defer db.Close()

    r := mux.NewRouter()

    r.HandleFunc("/login", login).Methods("POST")
    r.Handle("/books", authenticate(http.HandlerFunc(getBooks))).Methods("GET")
    r.Handle("/books", authenticate(http.HandlerFunc(createBook))).Methods("POST")

    fmt.Println("Server started on port :8000")
    log.Fatal(http.ListenAndServe(":8000", r))
}

Probándolo

Pongamos esto a prueba:

1. Agregar un nuevo libro:

   curl -X POST http://localhost:8000/books -d '{"title": "1984", "author": "George Orwell"}' -H "Content-Type: application/json"

1. Buscar todos los libros:

   curl http://localhost:8000/books

¡Y boom! Tienes una API Go con PostgreSQL, lista para manejar algunos datos reales.

¿Qué sigue?

La próxima vez, haremos que nuestra API sea aún más eficiente con algún middleware personalizado para el registro y el manejo de errores. ¡Estén atentos para más!