Tutorial API REST (Go Lang)

Requisitos

• Go instalado (versión 1.16 o superior).

• Servidor MySQL configurado.

• Conocimientos básicos de Go, SQL, y manejo de módulos.

• Herramienta de manejo de API como Postman o cURL para pruebas.

1. Crear el proyecto

Crea un directorio para tu proyecto y muévete a él:

mkdir go-contacts-api
cd go-contacts-api

Inicializa el módulo Go:

go mod init go-contacts-api

2. Instalar dependencias

Vamos a instalar las dependencias necesarias para manejar MySQL y las rutas:

go get -u github.com/gorilla/mux
go get -u github.com/go-sql-driver/mysql

3. Configuración de MySQL

1. Crea la base de datos y la tabla en MySQL:

Conéctate a tu servidor MySQL y ejecuta lo siguiente:

CREATE DATABASE contacts_db;

USE contacts_db;

CREATE TABLE contacts (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL,
    phone VARCHAR(15) NOT NULL
);

2. Configura un usuario con los permisos adecuados para la base de datos.

4. Estructura del proyecto

Dentro de tu directorio, crea los siguientes archivos:

• main.go

• database.go

• handlers.go

• models.go

5. Código fuente

main.go

Este archivo contiene el punto de entrada de la aplicación:

package main

import (
	"log"
	"net/http"
	"github.com/gorilla/mux"
)

func main() {
	// Inicializar la conexión a la base de datos
	InitDB()

	// Crear el router
	r := mux.NewRouter()

	// Definir las rutas de la API
	r.HandleFunc("/contacts", CreateContact).Methods("POST")
	r.HandleFunc("/contacts", GetContacts).Methods("GET")

	// Iniciar el servidor en el puerto 8080
	log.Println("API corriendo en http://localhost:8080")
	log.Fatal(http.ListenAndServe(":8080", r))
}

database.go

Este archivo manejará la conexión a MySQL:

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github.com/go-sql-driver/mysql"
)

var db *sql.DB

// InitDB inicializa la conexión a la base de datos
func InitDB() {
	var err error
	// Cambia los valores por tus credenciales de MySQL
	dsn := "usuario:contraseña@tcp(127.0.0.1:3306)/contacts_db"
	db, err = sql.Open("mysql", dsn)
	if err != nil {
		log.Fatal("Error al conectar a la base de datos:", err)
	}

	if err = db.Ping(); err != nil {
		log.Fatal("Error al hacer ping a la base de datos:", err)
	}

	fmt.Println("Conexión a la base de datos exitosa")
}

models.go

Define el modelo de contacto:

package main

type Contact struct {
	ID    int    `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email"`
	Phone string `json:"phone"`
}

handlers.go

Este archivo contendrá los controladores para crear y listar contactos:

package main

import (
	"encoding/json"
	"net/http"
	"strconv"
)

// Crear un nuevo contacto
func CreateContact(w http.ResponseWriter, r *http.Request) {
	var contact Contact
	if err := json.NewDecoder(r.Body).Decode(&contact); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}

	// Insertar el contacto en la base de datos
	query := "INSERT INTO contacts (name, email, phone) VALUES (?, ?, ?)"
	result, err := db.Exec(query, contact.Name, contact.Email, contact.Phone)
	if err != nil {
		http.Error(w, "Error al insertar contacto", http.StatusInternalServerError)
		return
	}

	id, _ := result.LastInsertId()
	contact.ID = int(id)

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

// Obtener contactos con paginación
func GetContacts(w http.ResponseWriter, r *http.Request) {
	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
	if page < 1 {
		page = 1
	}

	limit := 10
	offset := (page - 1) * limit

	query := "SELECT id, name, email, phone FROM contacts LIMIT ? OFFSET ?"
	rows, err := db.Query(query, limit, offset)
	if err != nil {
		http.Error(w, "Error al obtener contactos", http.StatusInternalServerError)
		return
	}
	defer rows.Close()

	var contacts []Contact
	for rows.Next() {
		var contact Contact
		if err := rows.Scan(&contact.ID, &contact.Name, &contact.Email, &contact.Phone); err != nil {
			http.Error(w, "Error al escanear contactos", http.StatusInternalServerError)
			return
		}
		contacts = append(contacts, contact)
	}

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

6. Ejecutar la aplicación

Compila y ejecuta la aplicación:

go run main.go

La API estará disponible en http://localhost:8080.

7. Pruebas de la API

Crear un contacto

Puedes usar cURL o Postman para probar la creación de un contacto:

curl -X POST http://localhost:8080/contacts \
-H "Content-Type: application/json" \
-d '{"name": "Juan Perez", "email": "juan@example.com", "phone": "+1234567890"}'

Listar contactos con paginación

Para listar contactos (de 10 en 10):

curl -X GET "http://localhost:8080/contacts?page=1"

Conclusión

Este tutorial cubre la creación de una API REST básica en Go con MySQL como backend. Puedes expandirla añadiendo autenticación, validación de datos, manejo de errores más robusto y más operaciones CRUD para mejorar su funcionalidad.