Environment variable
An environment variable is a named value supplied through an operating-system or process environment and made available to programs for runtime configuration or information.
Learn Docker in a Month of Lunches, Second Edition
An environment variable is a named key/value setting supplied by an operating system or execution environment to configure a process.
- How it is used
- Configures container behavior at deployment without rebuilding the image.
- How deep it goes
- Defines key/value settings and works through Dockerfile defaults, runtime overrides, Compose injection, configuration precedence, and a legacy-app adapter.
- Examples
- Uses a web-ping target override, Compose service settings, and environment selection for a .NET application.
- What you can do after
- Operate/configure it with Docker `--env`, Dockerfile `ENV`, or Compose settings, then check the resulting application behavior.
Read how Learn Docker in a Month of Lunches, Second Edition explains environment variable →
Road to Kubernetes
An environment variable is a named value supplied by the execution environment to configure or provide information to a process.
- How it is used
- Configures application ports and supplies deployment settings without changing application code or rebuilding a container image.
- How deep it goes
- Works through command-line settings, container fallbacks, environment files, and Kubernetes references; defers production secret-manager configuration.
- Examples
- Uses an Express.js port change, a Python container entrypoint, a Redis host setting, and Kubernetes Deployment manifests.
- What you can do after
- Operate/configure applications with runtime values and select direct, file-based, or Kubernetes-supplied settings for deployments.
Grokking AI Applications
An environment variable is a named configuration value supplied to a running process through its execution environment.
- How it is used
- Configures deployed or local Langflow processes with credentials, project names, and security settings.
- How deep it goes
- Explains deployment and local configuration, examples, and restart consequences without detailing process-level environment internals.
- Examples
- Uses Langflow administrator credentials, a secret key, and LangSmith connection variables as configuration examples.
- What you can do after
- Operate/configure Langflow by setting deployment or local variables and connecting it to LangSmith.
Read how Grokking AI Applications explains environment variable →
Kubernetes in Action, Second Edition
An environment variable is a named value supplied through a process environment and accessible to the process and its child processes.
- How it is used
- Configures containerized applications through per-container values supplied in pod manifests or drawn from Kubernetes objects.
- How deep it goes
- Works through literal values, references, inspection, and injected sources; defers file-based ConfigMap and Secret delivery.
- Examples
- Uses pod manifests, kubectl exec output, a status message, ConfigMap and Secret references, and pod metadata.
- What you can do after
- Operate/configure it in a pod manifest, inspect container values, and choose appropriate sources while recognizing Secret exposure risks.
Read how Kubernetes in Action, Second Edition explains environment variable →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
An environment variable is a named value supplied by the execution environment to configure a program without changing its source code.
- How it is used
- Configures microservices and supplies inputs to shell scripts used for automated deployment.
- How deep it goes
- Shows shell assignment, Node.js access, required-value errors, and workflow mappings; does not explore environment-variable internals.
- Examples
- Uses `PORT=3000`, metadata-service connection settings, and a workflow that maps a commit hash and registry secrets into variables.
- What you can do after
- Operate/configure a microservice with required settings and diagnose deployment failures caused by missing or differing variables.
Build AI-Enhanced Web Apps
A named configuration value supplied to a process through its execution environment rather than hard-coded application source.
- How it is used
- Supplies credentials, service configuration, and simple feature toggles to web applications without hard-coding values in source.
- How deep it goes
- Explains local loading, server-versus-browser exposure, and deployment configuration, with a missing-key check; does not elaborate secret rotation.
- Examples
- Uses OpenAI and Gemini API keys, Upstash connection values, and Clerk publishable and secret keys in application configurations.
- What you can do after
- Operate/configure it by separating public values from server secrets and setting deployment variables in Vercel.
Read how Build AI-Enhanced Web Apps explains environment variable →
Build Your Own Robot: Using Python, CRICKIT, and Raspberry Pi
An environment variable is a named operating-system value made available to programs at runtime for configuration or other contextual information.
- How it is used
- Configures robot motor adjustments and web-application debug behavior without hard-coding values in Python.
- How deep it goes
- Demonstrates Bash setup, Python lookup, missing-value defaults, string-to-float conversion, and integration into motor control.
- Examples
- Uses ROBO_DC_ADJUST_R and ROBO_DC_ADJUST_L to correct motor power, plus ROBO_DEBUG for a Tornado application.
- What you can do after
- Apply it via Python’s os module to configure motor throttle adjustments and Tornado debug behavior externally.
ASP.NET Core in Action, 3e
An environment variable is an operating-system-provided name-value setting that applications can read at runtime.
- How it is used
- Uses operating-system settings to supply ASP.NET Core secrets, hosting environments, and runtime configuration without project-file changes.
- How deep it goes
- Explains provider registration, hosting defaults, local profiles, and security limits, but defers detailed environment-variable naming syntax.
- Examples
- Uses ASPNETCORE_ENVIRONMENT, launchSettings.json profiles, and dotnet run --environment Staging as concrete configuration examples.
- What you can do after
- Operate/configure ASP.NET Core applications with production settings, local profiles, and environment-specific behavior.
Read how ASP.NET Core in Action, 3e explains environment variable →
Acing the Certified Kubernetes Administrator Exam, Second Edition
An environment variable is a named value made available to a process through its execution environment.
- How it is used
- Injects application configuration and sensitive values into containers, then supports troubleshooting failed startup.
- How deep it goes
- Explains environment-variable references through YAML and kubectl edits, but does not descend into process-environment internals.
- Examples
- Uses ConfigMap settings, Secret references, a MySQL password, kubectl commands, YAML manifests, and printenv verification.
- What you can do after
- Operate/configure Kubernetes containers with ConfigMap or Secret values and diagnose missing variables using logs and kubectl.
Quarkus in Action
An environment variable is a named configuration value supplied through a process or container execution environment.
- How it is used
- Deploys the same application artifact with instance-specific configuration in processes, containers, and Kubernetes environments.
- How deep it goes
- Explains runtime precedence, naming conversion, commands, and API distinctions without detailing container orchestration manifests.
- Examples
- Demonstrates GREETING in Quarkus Dev mode and contrasts environment-variable and system-property precedence.
- What you can do after
- Apply it via Quarkus by overriding application.properties values at process startup and reading configuration through MicroProfile Config.
Shipping Go: Develop, deliver, discuss, design, and go again
An environment variable is a named value supplied by the operating system or process environment to configure an application at runtime.
- How it is used
- Configures application behavior at startup without editing and rebuilding code.
- How deep it goes
- Works through Go environment loading, defaults, override order, and port validation; does not elaborate on environment-variable internals.
- Examples
- Shows a configurable Go counter and an API port overridden from a JSON file by `PORT=8081`.
- What you can do after
- Apply it via Go’s `os.Getenv` to load settings while preserving defaults for unset values.
Machine Learning Platform Engineering
An environment variable is a named value supplied through a process environment to configure or provide information to an application.
- How it is used
- Configures containers, Kubernetes workloads, and CI jobs without changing application code or rebuilding configuration logic.
- How deep it goes
- Explains declaration, injection, and credential handling through Dockerfile, Pod, ConfigMap, Secret, and GitLab examples.
- Examples
- Demonstrates ENVIRONMENT, DATABASE_URL, API_KEY, database credentials, and Docker registry credentials.
- What you can do after
- Operate/configure deployments by injecting settings through Docker, Kubernetes objects, and GitLab CI/CD variables.
Read how Machine Learning Platform Engineering explains environment variable →
Practical Automation with PowerShell: Effective scripting from the console to the cloud
An environment variable is a named value supplied by an operating-system or process environment to applications and scripts.
- How it is used
- Supplies Jenkins-scheduled PowerShell scripts with configurable parameters and execution-time credentials.
- How deep it goes
- Explains PowerShell access, lowercase Jenkins names, parameter replacement, credential bindings, and SecureString reconstruction.
- Examples
- Uses log-cleanup paths and retention settings plus SQL health-check credentials, server names, and SendGrid values.
- What you can do after
- Operate/configure Jenkins jobs that pass script parameters and credentials through PowerShell environment variables.
Build Financial Software with Generative AI (From Scratch)
An environment variable is a named value supplied through a process environment to configure software without embedding the value in source code.
- How it is used
- Configures Dockerized services and application connections without embedding credentials or deployment-specific values in source code.
- How deep it goes
- Demonstrates environment files, Docker wiring, Python retrieval, source-control protection, and documentation, but not deeper process-environment internals.
- Examples
- Uses PostgreSQL credentials, a Docker env_file directive, and Python os.getenv database configuration.
- What you can do after
- Operate/configure Docker services and application database connections while avoiding hardcoded sensitive values.
Read how Build Financial Software with Generative AI (From Scratch) explains environment variable →
Learn Rust in a Month of Lunches
An environment variable is a named operating-system or process setting represented as a string key and string value.
- How it is used
- Configures programs and supports debugging, logging, URLs, and other settings supplied by the operating system or process.
- How deep it goes
- Explains string key-value storage and Rust accessors, then demonstrates reading, listing, setting, and fallback configuration.
- Examples
- Uses RUST_BACKTRACE, RUST_LOG, LOGGER_URL, complete environment listings, and runtime key-value rewriting.
- What you can do after
- Operate/configure it by reading, listing, setting, and selecting Rust program behavior from environment values.
Read how Learn Rust in a Month of Lunches explains environment variable →
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
An environment variable is a named key-value setting made available to a running process through its execution environment.
- How it is used
- Configures AWS Lambda behavior by passing runtime settings such as a monitored URL and expected website text.
- How deep it goes
- Defines key-value settings, shows Lambda runtime access, and demonstrates changing a value to trigger a failed check.
- Examples
- Uses site and expected settings for a scheduled website health check, then changes expected to FAILURE to test monitoring.
- What you can do after
- Apply it via AWS Lambda to configure a health check and test its failure-monitoring path without changing the function logic.
Logs and Telemetry
An environment variable is a named value supplied by the operating system or process environment and made available to applications at runtime.
- How it is used
- Uses runtime values to adapt Fluent Bit destinations, credentials, tags, and container context without duplicating configurations.
- How deep it goes
- Explains shell setup, substitution syntax, startup failures, filter constraints, and configuration-level overrides.
- Examples
- Demonstrates `${myTag}`, shell export, `fluent-bit -c`, and `@set` through changing a Hello World tag.
- What you can do after
- Operate/configure Fluent Bit with shell-provided and configuration-defined values, while diagnosing unresolved substitutions.
Kubernetes for Developers
An environment variable is a named value supplied through a process environment to provide runtime configuration.
- How it is used
- Keeps runtime configuration outside container images across local, testing, and production environments.
- How deep it goes
- Explains practical configuration and Secret injection, but does not descend into process-environment internals.
- Examples
- Uses Compose database settings, Kubernetes service-discovery values, and a SECRET_KEY loaded from a Secret.
- What you can do after
- Configure applications with reusable runtime values and migrate password strings into Kubernetes Secrets.
Read how Kubernetes for Developers explains environment variable →
Modern C, Third Edition
An environment variable is a named string setting provided through a program's runtime environment.
- How it is used
- Transmits runtime-specific name–value settings into a C program.
- How deep it goes
- Explains name lookup, bounded copying, buffer-fit checks, and length reporting, while deferring dynamic allocation.
- Examples
- Uses HOME, PATH, LANG, LC_ALL, and a printenv helper as concrete settings and access examples.
- What you can do after
- Operate getenv and getenv_s to detect settings and retrieve values without overflowing a fixed destination buffer.
Read how Modern C, Third Edition explains environment variable →
Related concepts
- API keyconfigures · An API key is a credential used to identify or authorize a client accessing an application programming interface.
- configurationconfigures · A specification of settings, parameters, or component relationships that determines how a system, application, model, or process is structured or operates.
- configmapused by · A ConfigMap is a Kubernetes API resource that stores non-confidential configuration data as key-value pairs for use by workloads and other cluster components.
- command search pathincludes · The command search path is an ordered list of directories an operating system or command shell searches to locate executable programs.
- 12-factor appused by · A 12-factor app is an application developed, deployed, and operated according to twelve principles for portability, scalability, and maintainability.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.