Miljövariabler: vad de är, användning och konfiguration i mobilprojekt

Vad är miljövariabler

Miljövariabler är ett nyckel-värde-par som är tillgängligt för applikationsprocessen via operativsystemets API. De skickas till processen när den skapas och finns bara under dess körtid. Till skillnad från konfigurationsparametrar inbäddade i källkoden kräver miljövariabler ingen omkompilering för att ändra värden. Detta är en grundläggande princip i Twelve-Factor App som säkerställer en tydlig separation mellan kod och konfiguration.

Inom mobilutveckling löser miljövariabler problemet med olika konfigurationer för olika miljöer: utvecklaren använder en lokal server, testaren använder staging, användarna använder produktion. Istället för att lagra tre backend-URL:er i koden med if-else-villkorsoperatorer, skickar utvecklaren en URL via en miljövariabel vid byggskedet. Detta förenklar koden och eliminerar risken för oavsiktlig användning av produktionsservern i en testmiljö.

Den främsta fördelen är säkerhet: känslig data hamnar inte i databasen. API-nycklar, Firebase-hemligheter, backend-åtkomsttoken och certifikat laddas via CI/CD direkt till byggmiljön. Om en angripare får åtkomst till databasen hittar den inga hemligheter där, eftersom de lagras i CI-systemets skyddade lagringsutrymmen och skickas endast vid byggandet av den binära filen.

Varför miljövariabler behövs i mobilutveckling

Mobilprojekt har minst tre miljöer: development, staging och produktion. Varje miljö kräver sin egen uppsättning konfigurationer: server-URL, paketnamn, signeringsschema och push-certifikat. Utan miljövariabler måste utvecklaren manuellt ändra konfigurationen före varje bygge, vilket leder till fel: en bortglömd produktionsnyckel i ett testbygge kan orsaka att meddelanden skickas till riktiga användare eller att en betald API förbrukas.

Separation av miljöer

Miljövariabler gör det möjligt att byta backend utan att ändra kod: det räcker att ersätta värdet i variabeln API_BASE_URL. Funktionsflaggor (feature flags) hanteras via variabler som FEATURE_CHAT_ENABLED=true, vilket gör det möjligt att aktivera nya funktioner i staging utan påverkan på produktion. För varje miljö skapas en egen .env-fil som laddas vid byggskedet.

class AppConfig {
  static final String apiBaseUrl =
    const String.fromEnvironment('API_BASE_URL',
      defaultValue: 'http://localhost:8080');
}

Säkerhet för nycklar

Hårdkodade nycklar är en vanlig sårbarhet i mobilapplikationer. En angripare dekompilerar APK eller IPA med verktyg som jadx eller Hopper och extraherar hemligheter från den binära filen. Även obfuskering skyddar inte strängliteral — de hittas lätt i koden efter dekompilering. Miljövariabler löser detta problem genom att skicka nycklar via CI/CD vid byggskedet, där de maskeras i loggar.

object Config {
    val apiKey: String =
        System.getenv("API_KEY") ?: throw
            IllegalStateException("API_KEY not set")
}

CI/CD-integration

Miljövariabler integreras med byggpipelines: GitHub Actions, GitLab CI, Bitrise och CircleCI stöder hemliga variabler som inte visas i loggar. Vid byggskedet sätter CI in lämpliga värden beroende på gren eller tag: för develop-grenen används staging, för v*-taggen används produktion. Detta automatiserar processen och eliminerar den mänskliga faktorn, vilket garanterar att varje bygge får rätt konfigurationsuppsättning.

.env-filer och hanteringsbibliotek

Fil .env är standardsättet att lagra miljövariabler i formatet KEY=VALUE. Den inkluderas inte i databasen, istället läggs .env.example med en mall för alla variabler och tomma värden till i databasen. Varje utvecklare skapar sin egen .env-fil med lokala inställningar utan att påverka andra teammedlemmars konfiguration. För olika miljöer används separata filer: .env.dev, .env.stage, .env.prod.

# .env.example — mall för utvecklare
API_BASE_URL=http://localhost:8080
FEATURE_CHAT_ENABLED=true
SENTRY_DSN=

För mobilprojekt finns specialiserade bibliotek för att arbeta med .env-filer:

• flutter_dotenv (Flutter) — laddar variabler från .env vid körning via dotenv.load()
• BuildConfig (Android) — genererar typade fält från build.gradle-värden
• xcconfig (iOS) — ansluter konfigurationsfiler till olika Xcode-byggscheman
• react-native-config (React Native) — variabelhantering via .env-filer

Gren-inställningar i CI/CD gör det möjligt att byta ut olika .env-filer: .env.dev för testservrar, .env.stage för förhandsversion och .env.prod för publicering i appbutiker. Filer med hemligheter laddas från säkert lagringsutrymme (Vault, AWS Secrets Manager) och lagras inte i databasen. Detta garanterar att även om versionshanteringssystemet äventyras förblir hemligheterna skyddade.

Miljövariabler i iOS-projekt

iOS-ekosystemet använder xcconfig-filer för att hantera variabler på byggnivå. De ansluts till Xcode-scheman och gör det möjligt att åsidosätta värden för Debug- och Release-konfigurationer. xcconfig-filer stöder arv: en basfil med gemensamma inställningar och specifika filer för varje miljö kan skapas.

Konfiguration av xcconfig-filer

xcconfig-filer lagrar variabler i formatet KEY = VALUE och ansluts till byggschemat i Xcode via Configuration-inställningar. Variabler från xcconfig är tillgängliga i Info.plist via syntaxen $(VARIABLE_NAME), vilket gör det möjligt att använda olika paketidentifierare och appnamn för olika scheman. För snabb identifiering av miljön läggs suffixet Dev eller Staging till appnamnet.

# Config/Dev.xcconfig — utvecklingskonfiguration
API_BASE_URL = http://localhost:3000
BUNDLE_ID_SUFFIX = .dev
APP_DISPLAY_NAME = MyApp Dev

Swift-kod för att läsa variabler

För åtkomst till variabler vid körning i iOS används filen Configuration.swift, som läser värden från Info.plist via Bundle.main.object(forInfoDictionaryKey:). Detta tillvägagångssätt garanterar att variablerna bestäms vid byggskedet och är tillgängliga för applikationen omedelbart efter start. Värdena läses en gång vid initialisering av modulen och cachas för snabb åtkomst under applikationens livscykel.

enum AppEnvironment {
    static var apiBaseURL: URL {
        guard let urlString = Bundle.main
            .object(forInfoDictionaryKey: "API_BASE_URL"),
              let url = URL(string: urlString as! String)
        else { fatalError("API_BASE_URL is not configured") }
        return url
    }

    static var isChatEnabled: Bool {
        Bundle.main.object(
            forInfoDictionaryKey: "FEATURE_CHAT_ENABLED"
        ) as? Bool ?? false
    }
}

Miljövariabler i Android-projekt

Android stöder miljövariabler via BuildConfig — en automatiskt genererad klass vars fält definieras i modulens build.gradle-fil. BuildConfig skapas vid kompilering för varje flavor och byggtyp separat. Detta möjliggör olika värden för debug och release utan att använda villkorsoperatorer i koden, vilket ökar prestanda och säkerhet.

Konfiguration av BuildConfig-fält

BuildConfig-fält ställs in via buildConfigField i defaultConfig eller i specifika buildTypes. För varje miljö skapas en separat buildType eller productFlavor. Detta säkerställer strikt isolering av konfigurationer: debug använder lokal server, release använder produktion. BuildConfig-fält är statiskt typade, vilket eliminerar fel vid referens i koden.

// build.gradle (Module: app)
android {
    defaultConfig {
        buildConfigField "String", "API_BASE_URL",
            "\"http://localhost:8080\""
    }
    buildTypes {
        debug {
            buildConfigField "String", "API_BASE_URL",
                "\"http://dev.api.itsectr.com\""
        }
        release {
            buildConfigField "String", "API_BASE_URL",
                "\"https://api.itsectr.com\""
        }
    }
}

gradle.properties för gemensamma värden

Fil gradle.properties i projektroten lagrar globala Gradle-variabler. De är tillgängliga i alla moduler via syntaxen $variableName och används för att ange beroendeversioner, byggflaggor och API-nycklar. Till skillnad från BuildConfig fungerar gradle.properties endast i Gradle-konfigurationsfasen, inte i applikationens körning. Därför är lösenord och API-nycklar som anges i gradle.properties inte synliga i dekompilerad kod, eftersom de endast används för att generera BuildConfig vid kompilering.

# gradle.properties
SENTRY_DSN=https://key@sentry.io/project
MAPS_API_KEY=AIzaSy...

För säker överföring av hemligheter i Android-projekt rekommenderas att använda local.properties (exkluderad från VCS) eller ladda värden från CI/CD-variabler till build.gradle via System.getenv(). Detta garanterar att nycklar inte hamnar i databasen. Vid publicering i Google Play Console, se till att alla debug-nycklar har ersatts med produktionsversioner via olika buildTypes eller productFlavors med motsvarande BuildConfig-värden.