Guía práctica de variables de entorno en Go

Hola Habr! Le presento la traducción de Una guía sin sentido para las variables de entorno en Go by Enda Phelan.

Las variables de entorno son la mejor manera de almacenar configuraciones de aplicaciones, ya que se pueden configurar a nivel del sistema. Este es uno de los principios de la metodología de la aplicación Twelve-Factor , le permite separar las aplicaciones del sistema en el que se están ejecutando (la configuración puede variar significativamente entre implementaciones, el código no debe ser diferente).

Usar variables de entorno

Todo lo que se necesita para interactuar con las variables de entorno está en la biblioteca estándar del sistema operativo. Así es como obtener el valor de la variable de entorno PATH:

package main import ( "fmt" "os" ) func main() { // Store the PATH environment variable in a variable path, exists := os.LookupEnv("PATH") if exists { // Print the value of the environment variable fmt.Print(path) } } 

Y así, establezca el valor de la variable:

 package main import ( "fmt" "os" ) func main() { // Set the USERNAME environment variable to "MattDaemon" os.Setenv("USERNAME", "MattDaemon") // Get the USERNAME environment variable username := os.Getenv("USERNAME") // Prints out username environment variable fmt.Print(username) } 

Carga de variables de entorno desde un archivo .env

En una máquina de desarrollo, donde muchos proyectos se inician de inmediato, el almacenamiento de parámetros en entornos variables no siempre es conveniente; Sería más lógico dividirlos entre proyectos utilizando archivos env. Puede hacer esto, por ejemplo, usando godotenv : este es el dotenv portado a la biblioteca Go Ruby. Le permite establecer las variables de entorno necesarias para la aplicación desde el archivo .env.

Para instalar el paquete, ejecute:

 go get github.com/joho/godotenv 

Agregue la configuración al archivo .env en la raíz del proyecto:

 GITHUB_USERNAME=craicoverflow GITHUB_API_KEY=TCtQrZizM1xeo1v92lsVfLOHDsF7TfT5lMvwSno 

Ahora puede usar estos valores en la aplicación:

 package main import ( "log" "github.com/joho/godotenv" "fmt" "os" ) // init is invoked before main() func init() { // loads values from .env into the system if err := godotenv.Load(); err != nil { log.Print("No .env file found") } } func main() { // Get the GITHUB_USERNAME environment variable githubUsername, exists := os.LookupEnv("GITHUB_USERNAME") if exists { fmt.Println(githubUsername) } // Get the GITHUB_API_KEY environment variable githubAPIKey, exists := os.LookupEnv("GITHUB_API_KEY") if exists { fmt.Println(githubAPIKey) } } 

Es importante recordar que si el valor de la variable de entorno se establece en el nivel del sistema, Go usará este valor en lugar del especificado en el archivo env.

Ajustar variables de entorno en el módulo de configuración

Es agradable, por supuesto, tener acceso a las variables de entorno directamente, como se muestra arriba, pero mantener una solución así parece bastante problemático. El nombre de la variable es una cadena y, si cambia, imagine un dolor de cabeza que dará como resultado el proceso de actualización de referencias de variables en toda la aplicación.

Para resolver este problema, crearemos un módulo de configuración para trabajar con variables de entorno de una manera más centralizada y compatible.

Aquí hay un módulo de configuración simple que devuelve los parámetros de configuración en la estructura de configuración (también establecemos los valores predeterminados de los parámetros en caso de que no haya una variable de entorno en el sistema):

 package config import ( "os" ) type GitHubConfig struct { Username string APIKey string } type Config struct { GitHub GitHubConfig } // New returns a new Config struct func New() *Config { return &Config{ GitHub: GitHubConfig{ Username: getEnv("GITHUB_USERNAME", ""), APIKey: getEnv("GITHUB_API_KEY", ""), }, } } // Simple helper function to read an environment or return a default value func getEnv(key string, defaultVal string) string { if value, exists := os.LookupEnv(key); exists { return value } return defaultVal } 

A continuación, agregue los tipos a la estructura Config , ya que la solución existente solo admite tipos de cadenas, lo que no es muy razonable para aplicaciones grandes.

Cree controladores para los tipos bool, slice y entero:

 package config import ( "os" "strconv" "strings" ) type GitHubConfig struct { Username string APIKey string } type Config struct { GitHub GitHubConfig DebugMode bool UserRoles []string MaxUsers int } // New returns a new Config struct func New() *Config { return &Config{ GitHub: GitHubConfig{ Username: getEnv("GITHUB_USERNAME", ""), APIKey: getEnv("GITHUB_API_KEY", ""), }, DebugMode: getEnvAsBool("DEBUG_MODE", true), UserRoles: getEnvAsSlice("USER_ROLES", []string{"admin"}, ","), MaxUsers: getEnvAsInt("MAX_USERS", 1), } } // Simple helper function to read an environment or return a default value func getEnv(key string, defaultVal string) string { if value, exists := os.LookupEnv(key); exists { return value } return defaultVal } // Simple helper function to read an environment variable into integer or return a default value func getEnvAsInt(name string, defaultVal int) int { valueStr := getEnv(name, "") if value, err := strconv.Atoi(valueStr); err == nil { return value } return defaultVal } // Helper to read an environment variable into a bool or return default value func getEnvAsBool(name string, defaultVal bool) bool { valStr := getEnv(name, "") if val, err := strconv.ParseBool(valStr); err == nil { return val } return defaultVal } // Helper to read an environment variable into a string slice or return default value func getEnvAsSlice(name string, defaultVal []string, sep string) []string { valStr := getEnv(name, "") if valStr == "" { return defaultVal } val := strings.Split(valStr, sep) return val } 

Agregue nuevas variables de entorno a nuestro archivo env:

 GITHUB_USERNAME=craicoverflow GITHUB_API_KEY=TCtQrZizM1xeo1v92lsVfLOHDsF7TfT5lMvwSno MAX_USERS=10 USER_ROLES=admin,super_admin,guest DEBUG_MODE=false 

Ahora puede usarlos en cualquier lugar de la aplicación:

 package main import ( "fmt" "log" "github.com/craicoverflow/go-environment-variables-example/config" "github.com/joho/godotenv" ) // init is invoked before main() func init() { // loads values from .env into the system if err := godotenv.Load(); err != nil { log.Print("No .env file found") } } func main() { conf := config.New() // Print out environment variables fmt.Println(conf.GitHub.Username) fmt.Println(conf.GitHub.APIKey) fmt.Println(conf.DebugMode) fmt.Println(conf.MaxUsers) // Print out each role for _, role := range conf.UserRoles { fmt.Println(role) } } 

Hecho

Sí, hay paquetes que ofrecen una solución llave en mano para configurar su aplicación, pero ¿cuánto se necesitan si es tan fácil hacerlo usted mismo?

¿Y cómo gestiona la configuración en su aplicación?