OPINION
This doesn’t mean that there isn’t a server somewhere
running the function, it’s just that someone else is making
sure that it runs. FaaS allows for software developers to write
only their business logic and then upload it to a FaaS service,
with a public cloud provider like AWS. The running of the
servers that are powering the containers that track business
logic is completely abstracted away, leaving businesses with
the ability to focus only on the application’s development.
Why outsourcing makes sense
Due to the abstraction away from hardware and the
ephemeral nature of modern applications, within the
next few years, the more we remove ourselves and our
applications from the bare metal, the less likely we should
have to care about it. Think about it, if an operator is
running a totally serverless application on a public cloud,
not only is there no need for them to care about the
infrastructure behind it, but it’s also not possible for the
operator to monitor it. There’s no way to access the metrics
from the network or servers behind the containers that are
running the code.
In the case of containers, DevOps teams running
applications in containers across a well-built Kubernetes
cluster, or a managed cluster running in the cloud, shouldn’t
have to think about the hardware that’s running it. More
and more, the management of K8 clusters or similar will
be outsourced to the cloud, and neither the hardware
underneath these managed clusters nor the clusters
themselves will be of any real concern to the company
running the application. The reason that outsourcing this
kind of work makes sense is that with the abstraction of
computing, hardware and the running of it becomes more of
a commodity.
The need to embrace change
So, what does the future of monitoring look like? When it
comes to applications and workloads that are running on
modern infrastructure, it’s becoming more important to
focus on the application itself, rather than the workloads
running on the infrastructure. Using the data that can be
collected through metrics, logs and traces that are directly
pulled or pushed from a workload or application, we can
assess the current state of a system from observing its
external outputs to help us to better understand the state.
High cardinality in our monitoring data used to be a
non-pattern and something that everyone tried to avoid, but
to make an application observable, storing highly cardinal
data is a must in order to really delve into a problem when
it occurs. By identifying the part of the application that’s
causing issues, it’s possible to review the logs and check that
when the application is trying to write to a specific node of
your database cluster that the writes are not taking too long
and causing timeouts. Ultimately, in order to adapt, we need
to rely on infrastructure less than ever before, and in order to
understand the future, we must embrace change. n
Discover the Edge.
Smart Solutions. Real Business.
www.networkseuropemagazine.com
www.rittal.com
29