Configuration
A specification of settings, parameters, or component relationships that determines how a system, application, model, or process is structured or operates.
Learn Docker in a Month of Lunches, Second Edition
Application configuration is the set of settings that controls an application's runtime behavior.
- How it is used
- Uses configuration to vary application behavior across environments while deploying the same tested container image.
- How deep it goes
- Works through file and environment-variable layering, Compose injection, and named-environment files; leaves existing-Pod reload behavior as a lab question.
- Examples
- Compares access-log configuration API responses, switches a to-do app between database providers, and checks logging changes in container logs.
- What you can do after
- Apply it via Docker Compose overrides, environment files, and secrets to change logging and database settings without rebuilding images.
Read how Learn Docker in a Month of Lunches, Second Edition explains configuration →
Kafka for Architects
A configuration is a set of settings that specifies system behavior, including connection details, selected data, and polling parameters.
- How it is used
- Sets client behavior, connector integration, and Kafka cluster state through settings rather than application-code changes.
- How deep it goes
- Defines name-value client parameters and works through a connector configuration, then outlines GitOps reconciliation without a full operational guide.
- Examples
- Uses an operational data store producer, a JDBC source connector, and a Git-backed cluster change pipeline.
- What you can do after
- Operate/configure Kafka clients and connectors, and manage cluster changes as reviewed desired state.
Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
A configuration is a set of settings or instructions that specifies how an infrastructure resource or system should be provisioned or operated.
- How it is used
- Uses infrastructure configuration to provision, operate, reproduce, change, and remove resources with documented intent.
- How deep it goes
- Explains configuration through version control, deletion checks, and RICE principles, but stops short of showing configuration syntax.
- Examples
- Uses firewall rules, ticketed commits, tagged servers, unused cloud instances, usage metrics, and staged deletion as concrete examples.
- What you can do after
- Operate/configure infrastructure changes with traceable intent, reproducible environments, controlled deletion, and reduced variation.
ASP.NET Core in Action, 3e
Configuration is the set of external settings and secrets that control an application's runtime behavior.
- How it is used
- Keeps runtime settings and secrets outside compiled code so deployments can change behavior without recompilation.
- How deep it goes
- Explains provider loading, override order, and key access, but mentions custom providers without implementing one.
- Examples
- Uses store-map settings and secrets, plus changing production logging levels to investigate a problem.
- What you can do after
- Operate/configure an ASP.NET Core app with layered providers, environment-specific values, and safer secret storage.
Read how ASP.NET Core in Action, 3e explains configuration →
Kubernetes for Developers
Configuration is the set of declarative settings that specify how a service or system should operate.
- How it is used
- Records desired container and Kubernetes workload settings so deployments can be repeated and changed without reconstructing commands.
- How deep it goes
- Compares declarative files with imperative commands, then explains applying, reusing, exporting, and cleaning configuration without detailing every object field.
- Examples
- Uses a Docker Compose web service, a Kubernetes Deployment, namespace redeployment, and exported Deployment YAML.
- What you can do after
- Apply it via Docker Compose and kubectl to repeat local tests, deploy workloads, and carry configuration changes between environments.
Logs and Telemetry
A configuration is a set of declarative settings that controls Fluent Bit's behavior and processing pipeline.
- How it is used
- Defines Fluent Bit pipeline behavior, deployment delivery, and runtime settings from simple CLI runs through container and Kubernetes scenarios.
- How deep it goes
- Explains formats, includes, variables, HTTP settings, and custom-plugin pipelines, while deferring exhaustive edge cases and full configurations to referenced files.
- Examples
- Demonstrates Hello World includes, an HTTP input tested with Postman, and database-backed custom input and output plugins.
- What you can do after
- Operate/configure Fluent Bit with file formats, composition directives, runtime variables, and pipeline-specific settings.
Build Python Web Apps with Streamlit
A configuration file is a file that stores declarative settings and structured application data separately from program logic.
- How it is used
- Centralizes supported quantities, units, and conversion factors for UI choices and backend calculations.
- How deep it goes
- Works through a Python configuration module, dataclass structure, and backend lookups rather than an external configuration format.
- Examples
- Shows mass and length configurations with units including kilograms, grams, meters, and centimeters.
- What you can do after
- Build it from scratch as unit_config.py and add units without changing quantity-specific UI or conversion code.
Read how Build Python Web Apps with Streamlit explains configuration →
Akka in Action, Second Edition
Declarative settings that control the behavior and deployment of an Akka application.
- How it is used
- Externalizes application, ActorSystem, test, and cluster settings so deployments can vary without code changes.
- How deep it goes
- Explains hierarchical loading, fallback priority, lifted overrides, and ActorSystem access, then applies them to tests and cluster startup.
- Examples
- Uses JDBC defaults, debug-log test overrides, a lifted subapplication, and a word-counting cluster with roles and ports.
- What you can do after
- Operate/configure applications by layering defaults and targeted overrides for environments, tests, ActorSystems, and cluster nodes.
Read how Akka in Action, Second Edition explains configuration →
Go in Practice, Second Edition
Configuration is information that specifies how a program or system should operate.
- How it is used
- Supplies persistent application settings and environment-specific asset locations.
- How deep it goes
- Works through file parsers and template wiring, while deferring detailed JSON behavior.
- Examples
- Uses JSON, YAML, and INI files plus a flag-driven stylesheet URL in a web template.
- What you can do after
- Operate/configure it by loading file settings and supplying a deployment-specific asset location to a template.
Read how Go in Practice, Second Edition explains configuration →
Quarkus in Action
A configuration specification defines APIs and rules for supplying and accessing application configuration values.
- How it is used
- Centralizes Quarkus, extension, and application settings while allowing deployment-specific overrides.
- How deep it goes
- Explains property files, API access, overrides, and build-time phases, then demonstrates extension configuration without covering every configuration source.
- Examples
- Uses application.properties, quarkus.metadata.path, Swagger UI settings, and quarkus.http.port to illustrate configuration behavior.
- What you can do after
- Apply configuration through application.properties, MicroProfile Config, environment variables, system properties, and extension configuration roots.
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A set of values and settings that determine how a software component operates.
- How it is used
- Configures microservices and deployments with environment-specific values while keeping application code reusable.
- How deep it goes
- Explains required values, fail-fast validation, deployment manifests, shared Terraform variables, and repository trade-offs.
- Examples
- Uses a Node.js PORT variable, a Kubernetes YAML manifest, Terraform variables, and a separate application-configuration repository.
- What you can do after
- Operate/configure microservices by supplying required environment variables and managing deployment settings across environments.
React in Depth
A configuration is a set of settings that specifies how a software tool or rule behaves.
- How it is used
- Records project-level linting and formatting decisions so ESLint and Prettier enforce consistent code conventions.
- How deep it goes
- Shows rule settings, severities, configuration files, defaults, and enforcement steps; does not detail how either tool parses configuration internally.
- Examples
- Uses ESLint semicolon and quote rules plus Prettier tab and semicolon options as concrete project choices.
- What you can do after
- Operate/configure ESLint and Prettier with project preferences, then enforce them through editors, builds, or optional commit checks.
Practices of the Python Pro
Configuration is a set of values or steps that specifies how a software component or operation should behave.
- How it is used
- Uses mappings and declarative inputs to separate behavior choices from execution logic.
- How deep it goes
- Explains dictionary mappings, fallbacks, readability, complexity, and extensibility through worked Python examples.
- Examples
- Uses choice-to-message mappings, HTTP response formats, JSON and XML serializers, and Plotly graph configuration.
- What you can do after
- Apply it via Python dictionaries to replace growing conditionals and select response formats with fallbacks.
Read how Practices of the Python Pro explains configuration →
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
Configuration is a declarative specification of infrastructure resources, their properties, and their relationships.
- How it is used
- Defines infrastructure resources and their relationships so Terraform can infer creation order from value references.
- How deep it goes
- Explains dependency inference, file formats, testing choices, and authentication caveats without detailing a complete configuration listing.
- Examples
- Uses a web application with database and DNS dependencies and contrasting private-logging and public-website storage tests.
- What you can do after
- Apply it via Terraform to express resource dependencies and choose distinct configurations for tests with conflicting requirements.
Shipping Go: Develop, deliver, discuss, design, and go again
Settings or input values that control an application's behavior independently of its source code.
- How it is used
- Enables teams to alter functionality, endpoints, and environments while shipping and testing without rebuilding application code.
- How deep it goes
- Demonstrates environment variables, JSON files, defaults, flags, precedence, and dependency selection, but defers persistent storage.
- Examples
- Uses a configurable counter, port overrides, JSON configuration, environment variables, command-line flags, and selectable translation clients.
- What you can do after
- Operate/configure Go applications through defaults, files, environment variables, and flags, then select service implementations from loaded settings.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains configuration →
PostgreSQL Mistakes and How to Avoid Them
Database configuration is the set of settings that determines how a database system behaves and operates.
- How it is used
- Uses configuration to prepare PostgreSQL for production, diagnose operational failures, and avoid resource-related performance problems.
- How deep it goes
- Explains parameter effects, restart requirements, log symptoms, and assessment workflow, while stopping short of exhaustive workload-specific tuning.
- Examples
- Demonstrates pgbench dumps and restores, memory parameter changes, replication and connection errors, and temporary-file logging.
- What you can do after
- Operate/configure PostgreSQL by comparing workload evidence, adjusting suitable parameters, restarting when required, and investigating logs and activity.
Read how PostgreSQL Mistakes and How to Avoid Them explains configuration →
Elasticsearch in Action, Second Edition
A configuration is a set of settings that controls the behavior and operation of a software system.
- How it is used
- Guides administrators in preparing Elasticsearch clusters and indexes for production operation, scaling, search performance, and recovery.
- How deep it goes
- Explains configuration categories, file locations, and operational purposes, while stopping short of enumerating every available setting.
- Examples
- Uses elasticsearch.yml, log4j2.properties, jvm.options, installation configuration paths, and index shard and replica settings.
- What you can do after
- Operate/configure Elasticsearch by locating its settings, adjusting node and index behavior, and preparing deployments for production demands.
Read how Elasticsearch in Action, Second Edition explains configuration →
Practical Automation with PowerShell: Effective scripting from the console to the cloud
Configuration data is static input that supplies values and parameters to a script without containing executable commands.
- How it is used
- Drives adaptable server automation by supplying task parameters to reusable PowerShell functions.
- How deep it goes
- Explains JSON import, module storage, orchestration, logging, and command-safety boundaries, stopping short of configuration schema design.
- Examples
- Uses JSON server profiles, feature and service lists, firewall log sizes, registry baselines, and date offsets.
- What you can do after
- Apply configuration via PowerShell functions, log results, and validate corrected compliance settings.
Functional Design and Architecture: Examples in Haskell
A config is a collection of application settings that controls how software is initialized or operates.
- How it is used
- Selects concrete implementations and application behavior during startup while keeping business logic independent of implementation details.
- How deep it goes
- Explains configuration through architectural boundaries, injected interfaces, and startup choices, but does not specify a configuration-file format.
- Examples
- Uses vendor assets, device descriptions, reporting channels, command-line arguments, external files, and an application architecture diagram.
- What you can do after
- Operate/configure applications by selecting implementations at startup and injecting them into transport-agnostic business functions.
Read how Functional Design and Architecture: Examples in Haskell explains configuration →
.NET in Action, Second Edition
Configuration is the set of externally supplied settings that control an application's behavior.
- How it is used
- Controls environment-dependent application behavior while preserving reusable, immutable container images.
- How deep it goes
- Explains hierarchical sources, override precedence, section access, typed binding, startup behavior, and testing, but defers secret handling details.
- Examples
- Uses appsettings files, a ConfigController endpoint, TestOverwrite precedence checks, CosmosDbSettings, and Options.Create tests.
- What you can do after
- Operate/configure ASP.NET Core applications through layered settings and inject typed configuration into testable services.
Read how .NET in Action, Second Edition explains configuration →
Learn Haskell by Example
A configuration is structured application data containing settings such as paths, file restrictions, and resource bounds.
- How it is used
- Structures user-supplied limits and paths, then provides them as a read-only environment throughout file synchronization.
- How deep it goes
- Defines a concrete record and contrasts explicit passing with ReaderT, while deferring broader synchronization implementation details.
- Examples
- Uses a Config record containing paths, optional limits, and a file type, plus a ReaderT action printing source and destination paths.
- What you can do after
- Apply it via ReaderT and run configuration-dependent IO actions without repeating the environment argument.
The Well-Grounded Python Developer: How the pros use Python and Flask
Configuration data is information that determines how an application and its services are set up and run.
- How it is used
- Improves application sustainability by separating runtime settings for development, staging, and production environments.
- How deep it goes
- Explains environment separation, TOML sections, typed values, inheritance, loading, and secret generation without detailing the configuration library internals.
- Examples
- Uses MyBlog service settings, TOML files, FLASK_ENV, SECRET_KEY, Dynaconf, and Flask Debug Toolbar settings.
- What you can do after
- Configure a Flask application with Dynaconf, environment-specific TOML settings, and a privately generated secret key.
Building Distributed Applications that Work
The set of settings that determines how a software resource runs and connects to other resources.
- How it is used
- Makes configuration explicit when coordinating services and infrastructure in a distributed application.
- How deep it goes
- States that configuration should be explicit and consistent but gives no implementation steps or configuration details.
- Examples
- Names databases, storage, messaging, and identity as resources to configure consistently.
- What you can do after
- Understand configuration as an explicit part of a distributed system, alongside its services and infrastructure.
Read how Building Distributed Applications that Work explains configuration →
Related concepts
- API keyincludes · An API key is a credential used to identify or authorize a client accessing an application programming interface.
- credential storealternative to · A credential store is a protected system that securely stores, manages, and supplies authentication credentials to authorized clients.
- configuration provideruses · A configuration provider is a pluggable component that resolves configuration values from a designated external source.
- environment variableconfigured by · 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.
- language modelconfigures · A language model is a computational model that represents patterns in linguistic tokens to estimate sequence probabilities and predict or generate language from context.
- User Secretsused by · User Secrets is a development-time configuration feature that stores sensitive application settings outside project files and source-control repositories.
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.