4.1 Core Cloud Service Compute
4.1 Core Cloud Service Compute
4.1 Core Cloud Service Compute
com/c/TariqKhan
• Virtual machines
• Containers
• Azure App Service
• Serverless computing
Virtual machines, or VMs, are software emulations of physical computers. They include
a virtual processor, memory, storage, and networking resources. They host an operating
system (OS), and you're able to install and run software just like a physical computer.
And by using a remote desktop client, you can use and control the virtual machine as if
you were sitting in front of it.
Containers are a virtualization environment for running applications. Just like virtual
machines, containers run on top of a host operating system. But unlike VMs, containers
don't include an operating system for the apps running inside the container. Instead,
https://www.youtube.com/c/TariqKhan
containers bundle the libraries and components needed to run the application and use
the existing host OS running the container. For example, if five containers are running
on a server with a specific Linux kernel, all five containers and the apps within them
share that same Linux kernel.
Serverless computing is a cloud-hosted execution environment that runs your code but
completely abstracts the underlying hosting environment. You create an instance of the
service, and you add your code; no infrastructure configuration or maintenance is
required, or even allowed.
Explore Containers
If you wish to run multiple instances of an application on a single host machine,
containers are an excellent choice. The container orchestrator can start, stop, and scale
out application instances as needed.
1. Abstraction of servers: Serverless computing abstracts the servers you run on.
You never explicitly reserve server instances; the platform manages that for you.
Each function execution can run on a different compute instance, and this
execution context is transparent to the code. With serverless architecture, you
simply deploy your code, which then runs with high availability.
2. Event-driven scale: Serverless computing is an excellent fit for workloads that
respond to incoming events. Events include triggers by timers (for example, if a
function needs to run every day at 10:00 AM UTC), HTTP (API and webhook
scenarios), queues (for example, with order processing), and much more. Instead of
writing an entire application, the developer authors a function, which contains
both code and metadata about its triggers and bindings. The platform
automatically schedules the function to run and scales the number of compute
instances based on the rate of incoming events. Triggers define how a function is
invoked and bindings provide a declarative way to connect to services from within
the code.
3. Micro-billing: Traditional computing has the notion of per-second billing, but
often, that's not as useful as it seems. Even if a customer's website gets only one
hit a day, they still pay for a full day's worth of availability. With serverless
computing, they pay only for the time their code runs. If no active function
executions occur, they're not charged. For example, if the code runs once a day for
two minutes, they're charged for one execution and two minutes of computing
time.