Go Academy · Lekcja

Zmienne środowiskowe

Nadpisuj konfigurację zmiennymi środowiskowymi

Zmienne środowiskowe to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Dlaczego warto używać zmiennych środowiskowych

Metodyka Twelve-Factor App zaleca przechowywanie konfiguracji w środowisku. Zmienne środowiskowe pozwalają, aby ten sam plik binarny działał inaczej w środowiskach deweloperskim, testowym i produkcyjnym, bez edytowania plików.

Viper może nakładać zmienne środowiskowe na konfigurację z pliku.

Kolejność pierwszeństwa

Viper rozstrzyga wartość klucza, sprawdzając źródła w kolejności priorytetów (od najwyższego):

Jawne wywołania Set
Flagi
Zmienne środowiskowe
Plik konfiguracyjny
Wartości domyślne

Zmienna środowiskowa zastępuje więc wartość z pliku, ale ma niższy priorytet niż jawne wywołanie Set.

Włączanie obsługi zmiennych środowiskowych

viper.AutomaticEnv() informuje Viper, aby sprawdzał zmienne środowiskowe dla każdego żądanego klucza. Od tej chwili viper.GetString("port") sprawdzi zmienną środowiskową PORT.

viper.AutomaticEnv()
port := viper.GetString("port")

Dodawanie prefiksu

Aby uniknąć kolizji z niezwiązanymi zmiennymi środowiskowymi, ustaw prefiks:

viper.SetEnvPrefix("myapp")
Od tej pory klucz port jest mapowany na zmienną środowiskową MYAPP_PORT

Viper zamienia klucz na wielkie litery i dodaje przed nim prefiks oddzielony podkreśleniem.

viper.SetEnvPrefix("myapp")
viper.AutomaticEnv()
fmt.Println(viper.GetString("port")) // reads MYAPP_PORT

Obsługa zagnieżdżonych kluczy

Zmienne środowiskowe nie mogą zawierać kropek. Użyj zamiennika kluczy, aby mapować klucze rozdzielane kropkami na podkreślenia, dzięki czemu server.port stanie się SERVER_PORT.

replacer := strings.NewReplacer(".", "_")
viper.SetEnvKeyReplacer(replacer)
viper.AutomaticEnv()
// server.port -> SERVER_PORT

Powiązanie pojedynczej zmiennej

Zamiast trybu automatycznego można jawnie powiązać jeden klucz za pomocą viper.BindEnv. Jest to przydatne, gdy nazwa zmiennej środowiskowej nie jest zgodna z konwencją prefiksu.

viper.BindEnv("id", "ACCOUNT_ID")
fmt.Println(viper.GetString("id"))

Pakiet os biblioteki standardowej

Wewnętrznie odczyt odbywa się ze środowiska procesu, udostępnianego przez bibliotekę standardową za pomocą os.Getenv i os.LookupEnv.

os.Getenv zwraca pusty ciąg, jeśli zmienna nie jest ustawiona
os.LookupEnv zwraca drugą wartość typu bool informującą, czy zmienna była obecna

val, ok := os.LookupEnv("PORT")
if !ok {
    val = "8080" // default
}

Ustawianie zmiennych środowiskowych w Go

Można programowo ustawiać zmienne środowiskowe na potrzeby testów lub wartości domyślnych za pomocą os.Setenv. Właśnie tego użyjemy w kolejnym przykładzie, aby zademonstrować działanie zastępowania wartości.

os.Setenv("MYAPP_PORT", "9090")

Pusta zmienna a nieustawiona zmienna

Uwaga: zmienna środowiskowa ustawiona na pusty ciąg nadal jest obecna. os.LookupEnv zwraca ("", true). Jeśli używa się wyłącznie os.Getenv, nie można odróżnić wartości pustej od braku ustawienia, co ma znaczenie w przypadku flag przypominających wartości logiczne.

os.Setenv("FEATURE", "")
v, ok := os.LookupEnv("FEATURE")
fmt.Println(v == "", ok) // true true

Połączenie elementów (koncepcja)

Typowy przebieg uruchamiania wygląda tak: najpierw odczytaj plik zawierający wartości domyślne, a następnie wywołaj AutomaticEnv, aby zmienne środowiskowe wdrożenia miały pierwszeństwo. Zespół operacyjny może zmienić MYAPP_PORT bez modyfikowania pliku YAML.

viper.SetConfigName("config")
viper.ReadInConfig()
viper.SetEnvPrefix("myapp")
viper.AutomaticEnv()
fmt.Println(viper.GetInt("port"))

Wykonywalny przykład: demonstracja zastępowania zmiennej

Ten program korzystający z biblioteki standardowej imituje kolejność pierwszeństwa Viper: wartość domyślna z pliku jest zastępowana przez wartość ze środowiska.

package main

import (
    "fmt"
    "os"
)

func get(key, fileDefault string) string {
    if v, ok := os.LookupEnv(key); ok {
        return v
    }
    return fileDefault
}

func main() {
    os.Setenv("PORT", "9090")
    fmt.Println("port:", get("PORT", "8080"))
    fmt.Println("host:", get("HOST", "localhost"))
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę o konfiguracji za pomocą zmiennych środowiskowych.

Podsumowanie

Dowiedzieli się Państwo, jak zastępować konfigurację wartościami ze środowiska:

Zmienne środowiskowe mają wysoki priorytet w Viper, wyższy niż plik
AutomaticEnv wraz z SetEnvPrefix mapują klucze na format PREFIX_KEY
W przypadku zagnieżdżonych kluczy rozdzielanych kropkami należy używać SetEnvKeyReplacer
Biblioteka standardowa zapewnia tę obsługę za pomocą os.Getenv / os.LookupEnv

Często zadawane pytania

Czy lekcja „Zmienne środowiskowe” jest bezpłatna?

Tak — pełny tekst „Zmienne środowiskowe” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Zmienne środowiskowe”?

Nadpisuj konfigurację zmiennymi środowiskowymi Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Zmienne środowiskowe”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy