El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Implementación

Siguiente ►
►

En esta sección, vamos a llevar a cabo la implementación del proyecto final. Este proyecto integrará todos los conceptos y habilidades que has aprendido a lo largo del curso. Asegúrate de seguir cada paso cuidadosamente y de revisar los conceptos anteriores si es necesario.

Objetivos del Proyecto

El objetivo del proyecto es construir una aplicación web completa en Go que interactúe con una base de datos, maneje la concurrencia y tenga un despliegue seguro y eficiente. La aplicación será un sistema de gestión de tareas (To-Do List) con las siguientes características:

  1. Autenticación de Usuarios: Registro e inicio de sesión.
  2. Gestión de Tareas: Crear, leer, actualizar y eliminar tareas.
  3. Interfaz Web: Una interfaz web simple para interactuar con el sistema.
  4. API REST: Endpoints para operaciones CRUD.
  5. Despliegue: Despliegue en un servidor de producción.

Estructura del Proyecto

La estructura del proyecto será la siguiente:

/todo-app
    /cmd
        /server
            main.go
    /internal
        /auth
            auth.go
        /db
            db.go
        /handlers
            handlers.go
        /models
            models.go
        /routes
            routes.go
    /web
        /static
            /css
            /js
        /templates
            index.html
            login.html
            register.html
            tasks.html
    go.mod
    go.sum

Paso 1: Configuración del Proyecto

  1. Crear el Directorio del Proyecto:

    mkdir todo-app
cd todo-app

  2. Inicializar el Módulo Go:

    go mod init todo-app

  3. Instalar Dependencias Necesarias:

    go get github.com/gorilla/mux
go get github.com/jinzhu/gorm
go get github.com/jinzhu/gorm/dialects/sqlite

Paso 2: Configuración de la Base de Datos

  1. Crear el Archivo db.go en internal/db:

    package db

import (
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/sqlite"
)

var DB *gorm.DB

func Init() {
    var err error
    DB, err = gorm.Open("sqlite3", "todo.db")
    if err != nil {
        panic("failed to connect database")
    }
}

  2. Definir el Modelo de Tarea en internal/models/models.go:

    package models

import "github.com/jinzhu/gorm"

type Task struct {
    gorm.Model
    Title       string
    Description string
    Completed   bool
}

Paso 3: Configuración del Servidor

  1. Crear el Archivo main.go en cmd/server:

    package main

import (
    "log"
    "net/http"
    "todo-app/internal/db"
    "todo-app/internal/routes"
)

func main() {
    db.Init()
    r := routes.SetupRouter()
    log.Fatal(http.ListenAndServe(":8080", r))
}

  2. Configurar las Rutas en internal/routes/routes.go:

    package routes

import (
    "github.com/gorilla/mux"
    "todo-app/internal/handlers"
)

func SetupRouter() *mux.Router {
    r := mux.NewRouter()
    r.HandleFunc("/tasks", handlers.GetTasks).Methods("GET")
    r.HandleFunc("/tasks", handlers.CreateTask).Methods("POST")
    r.HandleFunc("/tasks/{id}", handlers.UpdateTask).Methods("PUT")
    r.HandleFunc("/tasks/{id}", handlers.DeleteTask).Methods("DELETE")
    return r
}

Paso 4: Implementación de Handlers

  1. Crear el Archivo handlers.go en internal/handlers: 
    package handlers

import (
    "encoding/json"
    "net/http"
    "todo-app/internal/db"
    "todo-app/internal/models"
    "github.com/gorilla/mux"
)

func GetTasks(w http.ResponseWriter, r *http.Request) {
    var tasks []models.Task
    db.DB.Find(&tasks)
    json.NewEncoder(w).Encode(tasks)
}

func CreateTask(w http.ResponseWriter, r *http.Request) {
    var task models.Task
    json.NewDecoder(r.Body).Decode(&task)
    db.DB.Create(&task)
    json.NewEncoder(w).Encode(task)
}

func UpdateTask(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    var task models.Task
    db.DB.First(&task, params["id"])
    json.NewDecoder(r.Body).Decode(&task)
    db.DB.Save(&task)
    json.NewEncoder(w).Encode(task)
}

func DeleteTask(w http.ResponseWriter, r *http.Request) {
    params := mux.Vars(r)
    var task models.Task
    db.DB.Delete(&task, params["id"])
    json.NewEncoder(w).Encode("Task deleted")
}

Paso 5: Implementación de la Interfaz Web

  1. Crear Plantillas HTML en web/templates:

    • index.html: 
      <!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>To-Do List</title>
</head>
<body>
    <h1>To-Do List</h1>
    <div id="tasks"></div>
    <script src="/static/js/main.js"></script>
</body>
</html>

  2. Crear Archivos Estáticos en web/static/js:

    • main.js: 
      document.addEventListener('DOMContentLoaded', function() {
    fetch('/tasks')
        .then(response => response.json())
        .then(tasks => {
            let tasksDiv = document.getElementById('tasks');
            tasks.forEach(task => {
                let taskElement = document.createElement('div');
                taskElement.innerText = task.Title;
                tasksDiv.appendChild(taskElement);
            });
        });
});

Paso 6: Despliegue

  1. Construir la Aplicación:

    go build -o todo-app cmd/server/main.go

  2. Desplegar en un Servidor:

    • Copia el binario todo-app y el archivo todo.db al servidor.
    • Ejecuta el binario en el servidor: 
      ./todo-app

Conclusión

En esta sección, hemos implementado un proyecto completo de gestión de tareas utilizando Go. Hemos cubierto la configuración del proyecto, la configuración de la base de datos, la configuración del servidor, la implementación de handlers, la creación de una interfaz web y el despliegue de la aplicación. Este proyecto integra todos los conceptos aprendidos a lo largo del curso y te proporciona una base sólida para desarrollar aplicaciones web en Go. ¡Felicidades por llegar hasta aquí!

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados