Worker
A worker is a person, process, thread, machine, or other execution resource that performs assigned work as part of a larger system or activity.
Build and Orchestrator in Go (From Scratch)
A worker is a machine or node in an orchestration system that executes assigned application tasks or jobs.
- How it is used
- Executes manager-assigned application tasks as containers while reporting local task and machine information for orchestration.
- How deep it goes
- Builds a worker from a stateful skeleton through queue processing, task transitions, Docker delegation, metrics, and failure behavior.
- Examples
- Demonstrates a Go worker starting and stopping a strm/helloworld-http container task and running multiple web-server instances across workers.
- What you can do after
- Build it from scratch as a Go worker that queues tasks, transitions their states, and starts or stops Docker containers.
Read how Build and Orchestrator in Go (From Scratch) explains worker →
ASP.NET Core in Action, 3e
A worker service is a headless .NET application whose primary function is to run hosted background tasks rather than serve user-facing web endpoints.
- How it is used
- Uses headless workers to run background tasks independently of HTTP-facing applications.
- How deep it goes
- Walks through template creation, hosted-service registration, production integration, and scaling tradeoffs.
- Examples
- Uses a per-second logging worker and an exchange-rate service that saves data with EF Core.
- What you can do after
- Operate and configure a worker using the .NET template, generic host, and Windows Service or systemd integration.
Data Pipelines with Apache Airflow, Second Edition
An Edge Worker is a worker process that registers with an Airflow API server and executes tasks assigned to it remotely.
- How it is used
- Executes scheduled DAG tasks, including tasks assigned to a remote environment through EdgeExecutor.
- How deep it goes
- Explains task pickup and Edge Worker registration, assignment, completion, and configuration, but not worker-process internals.
- Examples
- Uses on-premises and Kubernetes-cluster jobs, an executor-specific task override, and a worker-status CLI command.
- What you can do after
- Operate/configure an Edge Worker for remote task execution and inspect its status with the Airflow CLI.
Read how Data Pipelines with Apache Airflow, Second Edition explains worker →
Kubernetes for Developers
A worker Pod is a workload instance that performs units of work assigned by a coordinator.
- How it is used
- Runs continuously to take queued tasks that a web application cannot complete inline.
- How deep it goes
- Works through a Redis-backed worker loop, Deployment, replica tradeoff, and CPU autoscaling; does not show a separate result store.
- Examples
- Uses two Python Pods that calculate pi from Redis tasks, plus a 36-worker comparison of internal concurrency and replicas.
- What you can do after
- Build it from scratch as a Redis-backed worker Deployment, then operate and scale its Pods with Kubernetes.
Elixir in Action, Third Edition
A worker process is a supervised process that performs part of a service's operational work rather than organizing other processes.
- How it is used
- Handles service operations or independent requests while supervisors manage worker life cycles.
- How deep it goes
- Defines workers, demonstrates spawned request handlers, and places them in supervision trees; it stops short of exhaustive process internals.
- Examples
- Uses Todo.DatabaseWorker, to-do cache and server processes, and spawned file-read and file-write handlers.
- What you can do after
- Operate/configure concurrent services by separating work into workers and placing restart boundaries under supervisors.
Distributed Machine Learning Patterns
A machine or execution unit that processes assigned data and participates in distributed model training.
- How it is used
- Accelerates distributed training and batch processing by assigning independent data partitions or work items to parallel execution units.
- How deep it goes
- Explains partition consumption, gradient calculation, asynchronous operation, and parameter-server contention without specifying implementation APIs.
- Examples
- Uses partitioned training, grayscale image work queues, LeNet training, and Fashion-MNIST worker-only training architectures.
- What you can do after
- Evaluate worker parallelism against gradient conflicts, stale parameters, communication blocking, and the worker-to-parameter-server ratio.
Read how Distributed Machine Learning Patterns explains worker →
AI Agents in Action, Second Edition
A worker agent is an agent specialized in performing delegated tasks or a defined set of tools for an orchestrator.
- How it is used
- Delegates focused subgoals to specialized workers while an orchestrator coordinates the overall goal.
- How deep it goes
- Develops an adaptive orchestration loop with typed plans and decisions, worker initialization, result evaluation, and replanning.
- Examples
- Uses research and analysis workers to compare residential solar and wind energy, printing decisions and aggregated findings.
- What you can do after
- Build an orchestrator loop with research and analysis workers using the OpenAI Agents SDK.
Read how AI Agents in Action, Second Edition explains worker →
Amazon Web Services in Action, Third Edition: An in-depth guide to AWS
A worker is a background process that consumes tasks or messages and performs processing independently of a request-serving process.
- How it is used
- Decouples request handling from slower background work through queues and independent processing.
- How deep it goes
- Explains polling, processing, acknowledgement, retries, scaling, and fault tolerance with Node.js implementations.
- Examples
- Uses website screenshots and sepia-filtered image processing as queue-driven worker examples.
- What you can do after
- Build it from scratch as a Node.js process that consumes SQS messages, processes files, updates state, and acknowledges completion.
Read how Amazon Web Services in Action, Third Edition: An in-depth guide to AWS explains worker →
Go in Action, Second Edition
A worker service is a background process that performs scheduled or queued processing independently of request-serving services.
- How it is used
- Runs feed ingestion in the background so request-serving APIs remain responsive and decoupled from slow external providers.
- How deep it goes
- Defines single workers, buffered shared queues, configurable pools, submission, shutdown, and process-level operation.
- Examples
- Uses RSS feed URLs, NYT and BBC ingestion, a three-worker pool, periodic fetching, and terminal-based worker/API integration.
- What you can do after
- Operate a background Go worker, scale it with a configurable pool, submit queued work, and integrate it with an API.
Also covered in
- Python Concurrency with asyncio
- Algorithms Every Programmer Should KnowIn early access (MEAP)
- Designing Deep Learning Systems: A guide for software engineers
- Logs and Telemetry
- Fast Python: High performance techniques for large datasets
- MongoDB 8.0 in Action, Third Edition
- Designing AI SystemsIn early access (MEAP)
- ActiveMQ in Action
- The Well-Grounded Python Developer: How the pros use Python and Flask
What to know first
- containerA software container is an isolated execution environment that packages an application and its dependencies, typically sharing the host operating-system kernel.
- queueA queue is an ordered collection that holds items for retrieval or processing, commonly in first-in, first-out order.
- concurrencyConcurrency is the structuring or execution of multiple computational activities so their progress overlaps in time, whether or not they run simultaneously.
- CPUA central processing unit (CPU) is a computer processor that executes program instructions and performs general-purpose computational operations.
Related concepts
- queueuses · A queue is an ordered collection that holds items for retrieval or processing, commonly in first-in, first-out order.
- agent orchestrationused by · Agent orchestration is the coordination of agents, their tasks, tools, and interactions to accomplish a larger objective or workflow.
- contractuses · A contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- interfaceused by · An interface is a contract or boundary that specifies the operations, members, or data shape a type or component exposes, without prescribing its complete implementation.
Questions about worker
What is worker?
A worker is a person, process, thread, machine, or other execution resource that performs assigned work as part of a larger system or activity.
Which Manning books explain worker?
Build and Orchestrator in Go (From Scratch), ASP.NET Core in Action, 3e, Data Pipelines with Apache Airflow, Second Edition, Kubernetes for Developers, Elixir in Action, Third Edition, Distributed Machine Learning Patterns, AI Agents in Action, Second Edition, Amazon Web Services in Action, Third Edition: An in-depth guide to AWS and 1 more.
What should I know before learning worker?
Manning books that teach worker usually introduce container, queue, concurrency and CPU first.
What kinds of worker are there?
Kinds of worker include chief worker and resumable worker.
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.








