Variables de ambiente en Go con paquetes externos

Contenido del curso

Introducción y Configuración

Fundamentos de Go

Estructuras de Datos y Funciones

Manejo de Errores y Concurrencia

Buenas Prácticas en Go

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:006:33

Variables de ambiente en Go con paquetes externos

Curso de Go

Clase 27 de 28

Clase 27 / 28

Recursos

Utilizar variables de ambiente es clave para mantener seguros datos sensibles, como cadenas de conexión, claves de acceso o configuraciones específicas, en cualquier aplicación. Con el lenguaje Go, manejar estas variables, así como agregar paquetes externos desde repositorios como GitHub, es un procedimiento sencillo y eficiente.

¿Por qué usar variables de ambiente en un proyecto de Go?

Las variables de ambiente aseguran la protección de datos críticos. Usarlas en Go es tan simple como escribir una sola línea de código. Con esta práctica:

Proteges claves sensibles.
Adaptas fácilmente tu aplicación a diferentes entornos.
Mantienes tu código limpio y ordenado.

¿Cómo importar paquetes externos fácilmente en Go?

A diferencia de otros lenguajes como Node o Python que utilizan repositorios centralizados (npm y pip, respectivamente), Go no posee un repositorio centralizado. Sin embargo, te permite importar paquetes fácilmente desde GitHub u otros servicios similares. Los pasos son simples:

Crear un módulo en Go

Necesitas inicializar un módulo dentro de tu proyecto para gestionar los paquetes externos.

go mod init nombre-del-modulo

Agregar paquetes externos desde GitHub

Este comando descarga el paquete deseado y lo incluye automáticamente en tu proyecto.

go get github.com/autor/nombre-paquete

Luego podrás importarlo directamente en tu archivo .go usando la línea import.

¿Cómo trabajar con variables de ambiente desde un archivo .env?

Implementar la lectura de variables desde un archivo .env es sencillo en Go, especialmente usando paquetes externos. Luego de importar el paquete necesario, aplicas estos pasos:

Creación del archivo .env

Este archivo debe contener los datos que pretendes usar, como por ejemplo:

AppName=GoaMin
AppEmb=desarrollo
AppPort=8080

Configurar e invocar las variables en tu aplicación Go

Tu código puede verse como:

package main

import (
	"fmt"
	"log"
	"os"
	"github.com/joho/godotenv"
)

func main() {
	err := godotenv.Load()
	if err != nil {
		log.Fatal("Error cargando el archivo env")
	}
	
	appName := os.Getenv("AppName")
	appEnv := os.Getenv("AppEmb")
	appPort := os.Getenv("AppPort")
	
	fmt.Println("Nombre de la aplicación:", appName)
	fmt.Println("Entorno de la aplicación:", appEnv)
	fmt.Println("Puerto de la aplicación:", appPort)
}

Este enfoque permite acceder de manera rápida y eficiente a las variables definidas, tanto en tu proyecto como en las establecidas en el sistema operativo.

¿Cómo estás utilizando las variables de ambiente en tus proyectos de Go? Comparte tu experiencia en los comentarios.

Samuel Soto Hoyos

Hace un año

Aquí están las buenas prácticas al usar módulos Go, basadas en la información proporcionada:

Comprender la organización del código con módulos:
- Los programas Go se estructuran en paquetes, que son colecciones de archivos fuente en el mismo directorio que se compilan juntos.
- Un módulo es un conjunto de paquetes Go relacionados que se liberan de forma conjunta. Un repositorio Go, por convención, contiene un único módulo en su directorio raíz.
- El archivo go.mod en la raíz del módulo declara la ruta del módulo, la cual sirve como prefijo de la ruta de importación para todos los paquetes dentro de ese módulo.
- La ruta del módulo también es utilizada por el comando go para saber dónde descargar el módulo desde un repositorio remoto, por ejemplo, para golang.org/x/tools.
- Una ruta de importación para un paquete se forma uniendo la ruta del módulo con la ruta del subdirectorio del paquete dentro del módulo (ej., github.com/google/go-cmp/cmp). Los paquetes de la librería estándar no tienen un prefijo de ruta de módulo.
Inicialización y gestión de dependencias:
- Para iniciar un proyecto con módulos, ejecute go mod init <ruta_del_módulo>. Esto creará un archivo go.mod que rastreará las versiones de las dependencias de su proyecto.
- Para agregar, actualizar o degradar una dependencia, utilice el comando go get. Por ejemplo, go get golang.org/x/text@v0.3.5 establecerá una versión específica de una dependencia.
- Es una buena práctica usar go mod tidy para añadir automáticamente los requisitos de módulo faltantes para los paquetes importados y eliminar los requisitos de módulos que ya no se utilizan, manteniendo su archivo go.mod limpio y preciso.
- Las dependencias del módulo se descargan en el subdirectorio pkg/mod dentro de su GOPATH. Puede eliminar todos los módulos descargados con go clean -modcache.
Compatibilidad y versionado semántico:
- Los paquetes dentro de los módulos deben mantener la compatibilidad hacia atrás (backward compatibility) a medida que evolucionan, siguiendo la "regla de compatibilidad de importación". Esto significa que si un paquete antiguo y uno nuevo tienen la misma ruta de importación, el nuevo debe ser compatible con el antiguo.
- Como parte de la compatibilidad de Go 1, se aconseja no eliminar nombres exportados y fomentar el uso de literales compuestos etiquetados. Si necesita una funcionalidad diferente que rompa la compatibilidad, la práctica es añadir un nuevo nombre en lugar de modificar uno antiguo.
- Para rupturas de compatibilidad, se utiliza el versionado semántico y el versionado de importación semántico. Los módulos en su versión 2 o superior (ej., v2) deben incluir un sufijo de versión mayor en su ruta (ej., /v2). Esto asegura que paquetes en diferentes versiones mayores de un módulo tengan rutas de importación distintas, manteniendo la compatibilidad para los importadores.
Gestión de la cadena de herramientas Go:
- A partir de Go 1.23, puede utilizar go get para gestionar la cadena de herramientas Go como si fuera cualquier otra dependencia. Esto permite que Go descargue automáticamente las versiones actualizadas de la cadena de herramientas cuando sea necesario.
- Si su proyecto depende de un código que requiere una versión más reciente de Go (ej., Go 1.24), Go actualizará la directiva go en su archivo go.mod para reflejar este requisito y automáticamente buscará el entorno de ejecución de Go 1.24.
Recomendaciones generales para el desarrollo Go:
- Aunque puede definir módulos localmente, es una buena práctica organizar su código como si fuera a publicarlo algún día en un repositorio remoto.

Introducción y Configuración

Características y ventajas del lenguaje de programación Go

Instala Go en WSL con un comando

Paquetes en Go sin npm ni pip

Fundamentos de Go

Formas de declarar variables en Go

Conversión de tipos en Go

if else y operador módulo en Go

Cuatro formas de usar for en Go

Estructuras de Datos y Funciones

Sentencia switch en Go con ejemplos reales

Arreglos en Go: fijos e inferidos

Creación y uso de slices dinámicos en Go

Mapas en Go: creación, acceso y manipulación de datos clave-valor

Cómo crear y usar funciones personalizadas en Go

Retorno de múltiples valores en Go

Funciones variadic en Go con tres puntos

Funciones recursivas en Go con Fibonacci

Punteros en Go para optimizar rendimiento del sistema

Runas en Go: bytes vs caracteres reales

Declaración y uso de estructuras de datos en Go

Implementación de enumeradores en Go para controlar estados

Manejo de Errores y Concurrencia

Errores personalizados en Go

Goroutines y channels en Go

Select para ordenar goroutines en Go

Timeouts en goroutines con time.After

Workers en Go con goroutines y channels

Buenas Prácticas en Go

JSON con Marshal y Unmarshal en Go

Conversión de texto plano a hash con SHA256 en Go

Variables de ambiente en Go con paquetes externos

Cierre de curso de Go: consejos para consolidar el aprendizaje

Variables de ambiente en Go con paquetes externos