Serverless computing
Serverless computing is a cloud execution model in which a provider manages the underlying infrastructure and allocates or scales resources for application workloads.
Server-Side WebAssembly
Serverless computing is a cloud model in which the provider manages infrastructure and server operations while applications run in response to events or requests.
- How it is used
- Positions Wasm as a runtime choice for scale-to-zero serverless workloads where cold starts recur.
- How deep it goes
- Explains performance rationale and adoption trade-offs, but does not provide a serverless implementation or deployment procedure.
- Examples
- Uses inactive workloads that scale to zero and comparative response-time measurements for Wasm and traditional serverless applications.
- What you can do after
- Evaluate/understand when Wasm’s startup, memory, portability, and ecosystem trade-offs suit a serverless workload.
Read how Server-Side WebAssembly explains serverless computing →
Shipping Go: Develop, deliver, discuss, design, and go again
Function as a Service is a cloud service model that executes individual functions on demand while hiding server and runtime management from the developer.
- How it is used
- Deploys a small API quickly for customer feedback without first operating dedicated servers.
- How deep it goes
- Works through a Go function entry point, test-gated deployment, public access, and endpoint verification; does not detail platform internals.
- Examples
- Uses a Go translation endpoint, GitHub Actions deployment YAML, a French translation test, and a public browser request.
- What you can do after
- Apply it via Google Cloud Functions and GitHub Actions to deploy and check a tested Go HTTP function.
Google Anthos in Action
A serverless workload is an application workload whose infrastructure provisioning and capacity management are handled by a platform rather than directly by its operator.
- How it is used
- Deploys containerized, event-driven workloads while shifting infrastructure provisioning, scaling, and serving concerns to a platform.
- How deep it goes
- Explains platform features, Kubernetes abstractions, tuning controls, deployment commands, and Cloud Run trade-offs without detailing Knative internals.
- Examples
- Uses Knative Service YAML, kubectl inspection, generated URLs, curl verification, Cloud Run, Anthos, and GPU-backed workloads.
- What you can do after
- Operate/configure a container-based Knative service, inspect its revisions and routes, verify its endpoint, and choose between Cloud Run and Anthos.
Read how Google Anthos in Action explains serverless computing →
Microsoft Azure in Action
Serverless computing is a cloud execution model in which the provider manages server infrastructure while applications run code in response to events or requests.
- How it is used
- Positions serverless computing as a way to run focused application work and connect services without managing the underlying servers.
- How deep it goes
- Defines the model, compares hosting trade-offs, and sketches Azure workflows without detailing server infrastructure or a complete Cosmos DB trigger setup.
- Examples
- Uses photo resizing, workflow integration, and an Azure Function responding to Cosmos DB order changes as examples.
- What you can do after
- Apply it via Azure Functions and Logic Apps to assign focused tasks and workflows, while weighing Consumption-plan costs against other hosting options.
Read how Microsoft Azure in Action explains serverless computing →
Delivering Machine Learning Projects: From design to deployment
Serverless computing is a cloud execution model in which a provider manages infrastructure and servers while workloads run on demand.
- How it is used
- Deploys models for flexible, scalable, on-demand processing of bursty workloads.
- How deep it goes
- Compares workload fit, startup latency, pricing risk, and alternatives without detailing provider-specific implementation.
- Examples
- Uses AWS Lambda, Azure Serverless, GCP Cloud Functions, Lambda, Cloud Functions, Azure Functions, and Cloud Run.
- What you can do after
- Operate/configure a serverless model deployment by assessing latency, burstiness, pricing exposure, and migration options.
Effective Platform Engineering
Serverless is a cloud computing model in which a provider manages the underlying infrastructure and runs customer-supplied functions or workloads on demand.
- How it is used
- Deploys lightweight cloud functions quickly when standard vendor-managed orchestration is acceptable.
- How deep it goes
- Contrasts deployment speed and orchestration abstraction with Kubernetes extensibility, but does not detail serverless internals.
- Examples
- Uses JavaScript, Golang, Python, and Java functions alongside secret injection, code signing, traffic routing, and identity verification requirements.
- What you can do after
- Evaluate whether rapid function deployment outweighs the need for extensible governance and custom security controls.
Read how Effective Platform Engineering explains serverless computing →
Platform Engineering on Kubernetes
Serverless computing is an execution model in which the provider manages server infrastructure and applications run with capacity allocated on demand.
- How it is used
- Provides platform teams with on-demand containers, functions, autoscaling, and traffic controls for developer workloads.
- How deep it goes
- Explains Knative Services, autoscaling, scale-to-zero, resource generation, and traffic management, while deferring component internals.
- Examples
- Demonstrates a notification service manifest, kubectl inspection, generated URLs, and curl-based endpoint interaction.
- What you can do after
- Operate/configure a Knative Service, inspect its generated URL, and expose an application that scales with demand.
Read how Platform Engineering on Kubernetes explains serverless computing →
Quarkus in Action
A serverless platform is a cloud execution platform that automatically provisions, starts, scales, and stops application instances in response to requests.
- How it is used
- Deploys small Quarkus applications that automatically scale with requests and can avoid paying for idle capacity.
- How deep it goes
- Explains scaling, scale-to-zero, cold starts, native images, and Funqy basics, while deferring deeper Quarkus serverless integrations.
- Examples
- Uses Quarkus Funqy functions, including an annotated method that returns processed input.
- What you can do after
- Build it from scratch with Quarkus and Funqy, then target different FaaS providers through one function API.
Cloud Observability in Action
A serverless environment is an execution environment in which the provider manages the underlying servers and infrastructure for application code.
- How it is used
- Shifts infrastructure operations toward provider APIs and dashboards while outsourcing server maintenance.
- How deep it goes
- Explains access, patching, autoscaling, and observability boundaries, but stops short of implementation configuration.
- Examples
- Uses AWS Lambda monitoring in a provider console as its concrete serverless example.
- What you can do after
- Evaluate serverless suitability against operational effort, observability control, low-level requirements, and regulatory constraints.
Read how Cloud Observability in Action explains serverless computing →
Related concepts
- AWS Lambdaincludes · AWS Lambda is Amazon Web Services’ managed serverless computing service for running code in response to events or requests without managing servers.
- cloud computinguses · Cloud computing is the on-demand delivery of computing resources and services over a network from remotely managed infrastructure.
- containeruses · A software container is an isolated execution environment that packages an application and its dependencies while sharing the host operating system kernel.
- Knativeincludes · Knative is an open-source, Kubernetes-based platform for deploying and operating serverless and event-driven workloads.
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.