Docker Composeలో .env, env_file, environment తేడాలు

env file అని పిలిచే మూడు వేర్వేరు అంశాలు

Docker Composeలో పేర్లు ఒకేలా అనిపించే మూడు వేర్వేరు mechanisms ఉన్నాయి. .env file, Compose YAMLను చదివిన తర్వాత మరియు ఏదైనా validate లేదా run చేయడానికి ముందు, compose.yaml లోని ${VARIABLE} placeholdersను భర్తీ చేస్తుంది. env_file: attribute key/value జతల fileను container environmentలోకి load చేస్తుంది. environment: attribute compose fileలోనే రాసిన variablesను containerపై నేరుగా set చేస్తుంది. ఇవి పరస్పరం interchangeable కావు. రెండు mechanisms ఒకే keyను set చేసినప్పుడు, ఏది గెలుస్తుందో documented precedence order నిర్ణయిస్తుంది.

ఈ guideలో ప్రతి mechanism ఎలా పనిచేస్తుందో చూపిస్తాము. మీరు run చేయగల commandతో precedenceను నిరూపిస్తాము. తరువాత మరింత ముఖ్యమైన విషయాన్ని వివరిస్తాము: docker inspect run చేయగల ఎవరైనా environment variablesను చదవగలరు. అందువల్ల passwordsను వాటిలో ఉంచకూడదు. Compose files గురించి మీకు ఇంకా పరిచయం లేకపోతే, ముందుగా VPSపై Docker Compose ప్రాథమికాలు చదివి, configuration కోసం ఇక్కడికి తిరిగి రండి.

.env ఫైల్ container కోసం కాదు, compose file కోసం

ఒక directory సృష్టించి, అందులో రెండు files ఉంచండి.

mkdir -p ~/envdemo && cd ~/envdemo
printf 'ALPINE_TAG=3.20\n' > .env

services:
  demo:
    image: alpine:${ALPINE_TAG}
    command: printenv ALPINE_TAG

ఇప్పుడు Compose వాస్తవంగా ఏమి parse చేసిందో పరిశీలించండి.

docker compose config

Outputలో image: alpine:3.20 కనిపిస్తుంది. Placeholder కనిపించదు, ఎందుకంటే Compose fileను load చేస్తున్నప్పుడే interpolation జరిగింది. Compose project directoryలో .env కోసం చూస్తుంది: --project-directory తో directoryని set చేసి ఉంటే అది; లేకపోతే -f తో ఇచ్చిన మొదటి file ఉన్న directory; అది కూడా లేకపోతే ప్రస్తుత directory. YAML valuesలో కనిపించే ${NAME} placeholders ను ఇది substitute చేస్తుంది. Keys ఎప్పుడూ interpolated కావు. రెండుసార్లు రాసిన $$ substitution చేయకుండా literal dollar sign ను ఉత్పత్తి చేస్తుంది.

తర్వాత serviceను run చేయండి.

docker compose run --rm demo

printenv ALPINE_TAG status 1తో exit అవుతుంది మరియు ఏమీ print చేయదు. ఆ variable containerలో లేదు. ఇది అత్యంత సాధారణ అపార్థం: .env compose fileను configure చేసింది, processను కాదు. POSTGRES_PASSWORD=hunter2 కలిగిన .env fileను compose fileలోని ఏదైనా భాగం reference చేయకపోతే, అది మీ database కోసం అసలు ఏమీ చేయదు.

Variable unsetగా లేదా emptyగా ఉన్నప్పుడు ${NAME:-default} fallback valueను అందిస్తుంది. ${NAME:?message} Composeను start కాకుండా ఆపి, మీరు ఇచ్చిన messageను print చేస్తుంది. సురక్షితమైన default లేని valueకు ఇదే సరైన ఎంపిక.

env_file containerలో variables ను లోడ్ చేస్తుంది

env_file: attribute, container environment variables గా మారే విషయాలను కలిగిన ఒకటి లేదా అంతకంటే ఎక్కువ files పేర్లను సూచిస్తుంది.

printf 'GREETING=from_env_file\nAPP_MODE=production\n' > app.env

services:
  demo:
    image: alpine:3.20
    command: printenv GREETING
    env_file:
      - ./app.env

docker compose run --rm demo

ఇది from_env_file ను ముద్రిస్తుంది. File format సాధారణ KEY=value lines రూపంలో ఉంటుంది. ప్రతి line ఒక్క entry ను కలిగి ఉంటుంది. # తో ప్రారంభమయ్యే line comment గా పరిగణించబడుతుంది. ఇది shell format కాదు. అయితే Compose కొన్ని shell-లాంటి నియమాలతో దీనిని parse చేస్తుంది. చుట్టూ ఉన్న quotes తొలగించబడతాయి. అందువల్ల KEY="value" మరియు KEY=value ఒకే ఫలితాన్ని ఇస్తాయి. Double-quoted మరియు unquoted values లోని ${...} placeholders interpolate చేయబడతాయి. Single-quoted values మాత్రం ఉన్నట్లుగానే ఉపయోగించబడతాయి. export prefix అనుమతించబడుతుంది, కానీ అది అవసరం లేదు. = sign చుట్టూ ఉన్న spaces తొలగించబడతాయి. గమనించాల్సిన విషయం inline comment. Unquoted value లో space తర్వాత వచ్చే # comment ప్రారంభాన్ని సూచిస్తుంది. అందువల్ల # ఉన్న value ను quotes లో ఉంచండి.

env_file path లేకపోతే అది error గా పరిగణించబడుతుంది మరియు Compose ఆగిపోతుంది. ఆ file నిజంగానే లేకపోవచ్చని భావిస్తే, దాన్ని optional గా గుర్తించండి:

    env_file:
      - path: ./app.env
        required: false

environment inlineగా variables ను సెట్ చేస్తుంది

services:
  demo:
    image: alpine:3.20
    command: printenv GREETING
    environment:
      GREETING: from_environment

రెండు syntax రూపాలు ఆమోదించబడతాయి: పైన చూపిన mapping రూపం మరియు - GREETING=from_environment ను ఉపయోగించే list రూపం. రెండూ ఒకే విధంగా పనిచేస్తాయి. వీటిలో మరో ఉపయోగకరమైన విధానం ఉంది: విలువ లేని key, మీరు docker compose ను అమలు చేసిన shell నుంచి ఆ variable ను pass through చేస్తుంది. list రూపంలో అది విలువలేని - GREETING గా ఉంటుంది. mapping రూపంలో colon తర్వాత ఏమీ లేకుండా GREETING: గా ఉంటుంది.

    environment:
      - GREETING

GREETING=from_my_shell docker compose run --rm demo

అది from_my_shell ను print చేస్తుంది. shellలో GREETING సెట్ చేయకుండా దీన్ని అమలు చేస్తే Compose ఏ విలువనూ సెట్ చేయదు. ఎలాంటి warning కూడా చూపించదు. ఇలాంటి నిశ్శబ్ద pass-through వైఫల్యాలను తెలుసుకోవాలి. ఎందుకంటే ఖాళీ password variable తో ప్రారంభమైన service సాధారణంగా విజయవంతంగా start అవుతుంది. కానీ అది పూర్తిగా రక్షణలేకుండా అందుబాటులో ఉంటుంది.

ఏది ప్రాధాన్యత పొందుతుంది

Docker ప్రాధాన్యత క్రమాన్ని అత్యధికం నుంచి తక్కువ వరకు ఇలా నిర్వచిస్తుంది: కమాండ్ లైన్‌లోని docker compose run -e, ఆ తర్వాత మీ shell లేదా env file నుంచి విలువను పొందే environment లేదా env_file, ఆ తర్వాత compose file లోని సాధారణ environment, ఆ తర్వాత env_file, చివరగా image లో ముందుగానే చేర్చిన ENV directive.

రోజువారీ పనికి సంక్షిప్తంగా: environment: కంటే env_file: ప్రాధాన్యత పొందుతుంది. కమాండ్ లైన్‌లోని -e రెండింటికంటే ప్రాధాన్యత పొందుతుంది. దీన్ని ఒకే fileలో నిరూపించండి.

services:
  demo:
    image: alpine:3.20
    command: printenv GREETING
    env_file:
      - ./app.env
    environment:
      GREETING: from_environment

docker compose run --rm demo
docker compose run --rm -e GREETING=from_cli demo printenv GREETING

మొదటి కమాండ్ from_environment ను ముద్రిస్తుంది. అంటే environment:, app.env లోని విలువను భర్తీ చేసింది. రెండవ కమాండ్ from_cli ను ముద్రిస్తుంది. compose file లోని ఏదీ command line విలువను భర్తీ చేయదు.

మీ config వర్తించనట్లుగా container ప్రవర్తిస్తే, ఊహించవద్దు. docker compose config పూర్తిగా పరిష్కరించబడిన file ను ముద్రిస్తుంది. docker compose config --environment Compose ఉపయోగిస్తున్న interpolation variables ను ముద్రిస్తుంది. "నా env file పట్టించుకోలేదు" అనే చాలా నివేదికల్లో, రెండు వేర్వేరు స్థాయిల్లో ఒకే విలువ రెండుసార్లు సెట్ చేయబడి ఉంటుంది.

పర్యావరణ variables ఎందుకు leak అవుతాయి

environment: లో password సెట్ చేస్తే, అది container configuration లో disk పై నిల్వ అవుతుంది. docker group లో ఉన్న ఏ user అయినా దాన్ని చూడగలదు.

docker compose run -d --name leaky -e DB_PASSWORD=hunter2 demo sleep 300
docker inspect leaky --format '{{json .Config.Env}}'

Output లో "DB_PASSWORD=hunter2" plain text గా ఉంటుంది. మరో మూడు paths కూడా అదే value ను బయటపెడతాయి. docker compose config దాన్ని terminal కు print చేస్తుంది. అందువల్ల అది support forum లో paste అవుతుంది. Parent process వాటిని replacement environment తో ఉద్దేశపూర్వకంగా ప్రారంభించకపోతే, child processes variable ను default గా inherit చేస్తాయి. PID 1 వలే అదే user గా నడిచే process లేదా CAP_SYS_PTRACE కలిగిన process, దాన్ని /proc/1/environ నుంచి చదవగలదు. ప్రతిదీ root గా నడిచే container లో ఇది ప్రతి process కు సాధ్యమే. PID 1 root గా నడుస్తున్నప్పుడు unprivileged user గా నడిచే application కు ఆ file పై బదులుగా permission error వస్తుంది. అయితే ఆ variable దాని స్వంత environment లో ఇంకా ఉంటుంది. అదనంగా, application crash handlers సాధారణంగా మొత్తం environment ను log లేదా error report లో dump చేస్తాయి.

docker group సభ్యత్వం host పై root అధికారంతో సమానం. అందువల్ల దీన్ని privilege boundary గా పరిగణించలేరు. shared box పై ఆ group కు ఎందుకు పరిమితులు విధించాలో VPSలో కనీస అధికార user accounts లోని guide వివరిస్తుంది.

Compose secrets విలువను ఒక ఫైల్లో ఉంచుతాయి

Compose ఫైల్ ఆధారిత secrets కు మద్దతు ఇస్తుంది. విలువను environment లోకి చేర్చకుండా, ఫైల్‌గా container లోకి mount చేస్తుంది.

services:
  db:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password
secrets:
  db_password:
    file: ./db_password.txt

secret, container లోపల /run/secrets/db_password వద్ద mount అవుతుంది. slash తర్వాత ఉన్న పేరు, top-level secrets: block లోని secret పేరు.

_FILE suffix అనేది postgres, mysql మరియు mariadb సహా Docker Official Images ఉపయోగించే ఒక convention. ఆ entrypoint scripts VARNAME_FILE కోసం తనిఖీ చేసి, ఫైల్‌ను చదివి, దాని కంటెంట్‌ను ఉపయోగిస్తాయి. ఇది Docker feature కాదు. కాబట్టి image దీన్ని అమలు చేసినప్పుడు మాత్రమే పనిచేస్తుంది. SOMETHING_FILE గౌరవించబడుతుందని భావించే ముందు image documentation ను తనిఖీ చేయండి. దీనికి మద్దతు ఇవ్వని applications startup సమయంలో ఫైల్‌ను స్వయంగా చదవగలవు. లేదా path ను pass చేసి, మీ స్వంత entrypoint ద్వారా చదివించవచ్చు.

నడుస్తున్న container లోపల నుంచి ధృవీకరించండి:

docker compose exec db cat /run/secrets/db_password
docker compose exec db printenv POSTGRES_PASSWORD

మొదటి command password ను చూపిస్తుంది. రెండవది ఏమీ చూపించదు, ఎందుకంటే విలువ environment లోకి ప్రవేశించలేదు. ఇదే ముఖ్య ఉద్దేశ్యం: ఈ container పై docker inspect harmless path మాత్రమే చూపిస్తుంది.

Host పై source file కు తగిన రక్షణ కల్పించండి. ఎందుకంటే secret భద్రత, దాని వెనుక ఉన్న file భద్రతకు మాత్రమే సమానం:

chmod 600 db_password.txt

VPSలో ఆచరణాత్మక మధ్యమార్గం

చాలా స్వయంగా నిర్వహించే images, _FILE variablesకు మద్దతు ఇవ్వవు. అందువల్ల ప్రవేశానికి environment variables మాత్రమే మార్గం. ఒకే administrator నిర్వహించే VPSలో వాస్తవిక లక్ష్యం, మీ project directoryలోని అందరికీ చదవగలిగే fileలో విలువలు ఉండకుండా చేయడం మరియు వాటిని gitలోకి వెళ్లకుండా చూడడం.

sudo install -o root -g root -m 600 /dev/null /etc/myapp/app.env
sudo nano /etc/myapp/app.env

    env_file:
      - /etc/myapp/app.env

install -m 600 fileను ముందుగానే సరైన modeతో సృష్టిస్తుంది. అందువల్ల అది అందరికీ చదవగలిగే స్థితిలో ఉండే సమయం ఉండదు. దానికి root యజమాని కాబట్టి, ఆ systemలోని non root user దాన్ని చదవలేడు. అయితే docker అమలు చేయగల ఎవరైనా container నుంచి ఆ విలువను చదవగలరు. *.env మరియు .envలను .gitignoreకు జోడించండి. వాటి బదులుగా key namesతో, ఖాళీ విలువలతో ఉన్న app.env.exampleను commit చేయండి. Commit చేసిన passwordను rotate చేయాలి.

విలువను rotate చేయడం అంటే serviceను restart చేయడం. Container process ప్రారంభమైనప్పుడు environment variablesను ఒక్కసారి మాత్రమే చదువుతుంది. అందువల్ల fileను సవరించినా, మీరు docker compose up -d --force-recreate db అమలు చేసే వరకు ఎలాంటి మార్పు ఉండదు. ఇది VPSలో HTTPS వెనుక n8n guideలో ఉపయోగించిన అదే విధానం. అందులో encryption key compose file వెలుపల ఉంటుంది.

ప్రతి వాతావరణానికి విడిగా configuration

Compose డిఫాల్ట్‌గా project directory నుంచి .env ను చదువుతుంది. --env-file తో దాన్ని వేరే స్థానానికి సూచించండి.

docker compose --env-file .env.staging config

బహుళ files క్రమంలో చదవబడతాయి. తర్వాతి files, ముందు files లోని విలువలను override చేస్తాయి. రహస్యంకాని default విలువలను committed file లో ఉంచండి. secrets ను server ను ఎప్పటికీ విడిచిపెట్టని file లో ఉంచండి. ఇదే env_file: కు కూడా వర్తిస్తుంది. ఒకే key పలుమార్లు ఉంటే, చివరగా జాబితా చేసిన file లోని విలువ అమలవుతుంది.

FAQ

నా .env ఫైల్ container లో ఎందుకు పట్టించుకోబడటం లేదు?

అది పట్టించుకోకుండా ఉండటం కాదు. .env ఫైల్ compose file లోని ${NAME} placeholders ను భర్తీ చేస్తుంది. ఇది COMPOSE_PROJECT_NAME లేదా COMPOSE_FILE వంటి Compose స్వంత variables ను కూడా సెట్ చేయగలదు. కానీ ఇది container లోని variables ను ఎప్పుడూ సెట్ చేయదు. విలువను container లోకి పంపాలంటే దాన్ని ఇలా reference చేయండి: environment: { KEY: "${NAME}" }. లేదా env_file: ./that-file.env ను ఉపయోగించండి.

environment, env_file పై ప్రాధాన్యం కలిగి ఉంటుందా, లేక దానికి విరుద్ధమా?

environment: కు ప్రాధాన్యం ఉంటుంది. Docker documentation లో పేర్కొన్న క్రమం ప్రకారం environment attribute, env_file attribute కంటే పై స్థాయిలో ఉంటుంది. Command line లోని docker compose run -e రెండింటికంటే పై స్థాయిలో ఉంటుంది. ఒక key రెండు చోట్లా సెట్ చేసి ఉంటే, env_file లోని విలువ మౌనంగా ఉపయోగించబడదు.

Compose ఉపయోగించే తుది విలువను ఎలా చూడాలి?

పూర్తిగా పరిష్కరించిన compose file ను, అన్ని interpolation అమలైన తర్వాత, చూపించడానికి docker compose config ను అమలు చేయండి. ఇప్పటికే నడుస్తున్న container కోసం, దాని process కు అందిన విలువను ఖచ్చితంగా చూడటానికి docker inspect <container> --format '{{json .Config.Env}}' ఉపయోగించండి.

Compose secrets encrypt చేయబడతాయా?

కాదు. File based secret ను /run/secrets/<name> వద్ద plain file గా container లో mount చేస్తారు. Source file కూడా host disk పై encryption లేకుండా ఉంటుంది. దీని ప్రయోజనం encryption కాదు, scope నియంత్రణ. విలువ container environment లోకి, docker inspect output లోకి, లేదా environment ను ముద్రించే crash dumps లోకి వెళ్లదు.

env file లో quotes మరియు spaces ఉపయోగించవచ్చా?

అవును. Compose బయట ఉన్న quotes ను తొలగిస్తుంది. అందువల్ల KEY="value with spaces" మరియు KEY=value with spaces రెండూ value with spaces ను ఇస్తాయి. Interpolate చేయకూడని $ విలువలో ఉంటే single quotes ఉపయోగించండి. # ఉన్న ఏ విలువనైనా quotes లో ఉంచండి, ఎందుకంటే quotes లేకుండా అది comment గా పరిగణించబడుతుంది. = చుట్టూ ఉన్న spaces తొలగించబడతాయి. అందువల్ల KEY = value ఇప్పటికీ KEY ను సెట్ చేస్తుంది.