Serverless Computing
Serverless computing lets you run applications without provisioning or managing the underlying servers. A provider allocates and scales resources in response to demand while you design the code, data, permissions, and service connections.
itCloud computing | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic - Serverless Computing
Serverless Computing is the subject of this course. Serverless computing is a cloud operating model. You deploy code or configure a managed service.
The useful unit of work is a closed loop: clarify the goal and boundaries, gather the inputs the practice requires, make the decision or change, record evidence, and return with owners for the next cycle. Skipping any link leaves teams busy without durable results.
Tooling supports the loop; it does not replace it. Choose tools after the boundary and evidence model are clear. Comparing products without that model produces feature matrices that do not change how the work runs.
Common failure modes include undefined ownership, metrics that count activity instead of outcomes, and irreversible steps taken without a review path. Treat those as design defects in the practice, not as individual heroics to compensate later.
Operators should be able to explain which signals would change a decision this week. If no signal can change the plan, the practice has become ritual. Keep the feedback path short enough that evidence still influences the next cycle.
Name the owners for each stage of the loop before the work scales. Unowned stages become permanent exceptions. Record decisions with enough context that a future operator can tell why a tradeoff was accepted. Prefer fewer, sharper metrics that change behavior over broad dashboards that only describe activity after the fact.
Read the Intro for the core model. Use the Cheatsheet when you need the operating map. Updates tracks official guidance when this course configures an update source; otherwise the practice is settled without a live feed.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://glossary.cncf.io/serverless/
Supports
- Serverless abstracts physical machines and provisioning behind provider-managed interfaces
- Resources scale with application demand and usage-based charging is common
- Serverless is broader than function as a service
- https://www.cncf.io/blog/2018/02/14/cncf-takes-first-step-towards-serverless-computing/
Supports
- Serverless applications are deployed in finer-grained units and executed and scaled in response to demand
- Function as a service and backend as a service are distinct parts of the serverless landscape
- Provider interoperability and portability remain design concerns
- https://cloudevents.io/
Supports
- CloudEvents is a specification for describing event data in a common way
- A common event description improves consistency, tooling access, and portability across event sources
- https://docs.aws.amazon.com/wellarchitected/latest/serverless-applications-lens/general-design-principles.html
Supports
- Functions should be concise and single-purpose
- Required state should use durable storage rather than temporary execution resources
- Concurrency, events, explicit workflow orchestration, retries, duplicate delivery, and idempotency are core design concerns
- https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtime-environment.html
Supports
- A managed execution environment has initialization, invocation, and shutdown behavior
- New-environment initialization creates cold-start latency and retained environments may serve warm invocations
- Package size, dependency loading, and initialization work affect startup latency
- https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html
Supports
- Concurrency is the number of in-flight function requests
- A platform adds execution environments as concurrent demand grows
- Concurrency controls can reserve capacity, cap a function, or pre-initialize environments
- https://docs.aws.amazon.com/wellarchitected/latest/serverless-applications-lens/security-pillar.html
Supports
- Provider-managed patching removes some infrastructure tasks
- Identity, detective controls, infrastructure protection, data protection, incident response, and application security remain necessary
- Misconfigured permissions remain an application risk
- https://docs.cloud.google.com/functions/docs
Supports
- Managed functions can be single-purpose and respond to HTTP or CloudEvents triggers
- Users deploy functions without managing the server or runtime environment
- Provider documentation still exposes quotas, limits, runtime lifecycle, cost, and deployment concerns
- https://learn.microsoft.com/en-us/azure/architecture/serverless/event-hubs-functions/resilient-design
Supports
- Event-driven consumers should account for retries, checkpoints, duplicate events, and failed-event handling
- At-least-once delivery can repeat an event
- Idempotent consumption prevents repeated processing from causing repeated business effects
- https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-available-cloudwatch-metrics.html
Supports
- Oldest-message age measures the age of the oldest unprocessed queue message
- Visible-message count reflects current queue backlog
- A growing backlog can indicate under-provisioned or stuck consumers
- https://knative.dev/docs/serving/autoscaling/scale-to-zero/
Supports
- Knative can reduce serving replicas to zero
- Scale-to-zero behavior has platform configuration and timing controls
- https://github.com/anaibol/awesome-serverless
Supports
- The curated list includes Serverless Framework, Knative, OpenFaaS, LocalStack, and Serverless Examples
- The list describes these entries as serverless platforms, frameworks, development tools, or examples
- https://www.serverless.com/
Supports
- Serverless Framework provides tooling for developing and deploying function-based applications and related infrastructure
- https://knative.dev/
Supports
- Knative provides serving and eventing components for serverless workloads on Kubernetes
- https://www.openfaas.com/
Supports
- OpenFaaS packages functions with containers and targets Kubernetes-based operation
- https://localstack.cloud/
Supports
- LocalStack provides a local environment for emulating AWS service integrations
- https://github.com/serverless/examples
Supports
- Serverless Examples provides ready-to-deploy examples across runtimes and cloud providers
