Imagine sitting down at a fancy $50 a plate restaurant and tearing into a 16
oz steak with your teeth instead of cutting it. Not only would this be a
pretty frustrating experience, but you'd probably be getting a look from your
boss as he wonders why he's still letting you expense dinner. And as with
steak, software becomes much easier to manage if you split it up into smaller
chunks before eating, or rather using it. This approach is actually used by
lots of larger services today, where they split whatever it is they're
providing into lots of small microservices. And our friends at IBM
sponsored this video so we could tell you all about it. To explain what a
microservice is, let's imagine you're using a site like Netflix. Every time
you perform some small action on the website, skipping forward, logging in,
paying a bill, all of these functions are handled by different dedicated
microservices, a concept that Netflix actually pioneered. And all of them are
held in virtual containers. You see, the traditional way for a site to handle
tons of users at once was to run lots of
separate instances of the same code in virtual machines or VMs. You can learn
more about virtualization in this video, but the basic idea is that a VM is a
separate session of an operating system running inside another OS. And a typical
server can run many VMs at once, which helps a great deal when many people are
accessing a site. But running a full VM and the associated software that you
need typically requires millions of lines of code, and oftentimes a user
wanting to complete just a simple task might require the server to open up more
full VMs, which is pretty inefficient and can end up hogging CPU cycles and
other resources. Microservices in containers, by contrast, only contain
the code for a specific task. So we
could be talking about just a few thousand lines of code instead of
millions. Going back to our Netflix example, you might have one container
for credit card authentication, another for the review system, another for the
volume slider, and so on and so forth. So if lots of people are using certain
microservices, the system can just create more instances of that specific
container instead of having to open up more full fat VMs. In fact, Google runs
about 2 billion containers at any given time because they're so easy to scale,
thanks in part to a system called Kubernetes, the Greek word for captain,
which Google developed to manage containers automatically. And although
this sounds like it might only be relevant to network engineers, it
actually has real benefits for you, the home consumer. If there's a problem with
a service, or if the developers want to add a new feature, they don't have to
search through 10 million lines of code to find the issue and then possibly
break the entire thing in the process. Instead, they can just change the one or
two microservices that they want and leave the others untouched, meaning that
fixes and new features can be pushed out quickly with less risk of causing other
problems. The container paradigm also offers speed enhancements, as servers
can run smaller microservices much more easily without tons of VMs slowing them
down. This has back-end reliability implications, too, because it usually
takes mere seconds to deal with a problematic container, meaning that the
potential for lengthy amounts of downtime is lower. So all this means
that containers are being used for tons of applications. Games like League of
Legends and Fortnite rely heavily on containers to reduce lag by easing the
load on their servers. And Pokémon Go also used containers to fix issues
shortly after the game's launch and add new features without disrupting the
millions of users who were playing the game at the time. Banks are also using
containers with Kubernetes to handle loads of transactions at once without
slowdowns. And even IBM's supercomputer Watson, which has been heavily utilized
in the healthcare industry, has transitioned to using containers instead
of monolithic virtual machines. So it turns out that small containers have
actually made life a lot easier. It's kind of like digital Tupperware. A big
thanks to IBM for sponsoring this video. IBM's LinuxONE is one of their
incredible business machines. That's what IBM stands for, you know. No, I'm
just kidding. It's It's International. Doesn't matter. Anyway, the LinuxONE is
their ultimate container and Kubernetes platform using Red Hat OpenShift.
LinuxONE comes with all sorts of great security gizmos like hardware
encryption, so your containers are going to be much better protected from all
sorts of nasty attacks. And LinuxONE can handle loads of containers, up to 2.4
million on a single system. And it can even handle really big containers, which
is useful if you are containerizing your existing monolithic applications before
you refactor them into microservices. This means that your apps run more
reliably, especially when lots of people are using them. Finally, your containers
can run on the exact same system as your data, so you don't suffer delays while
data travels across the network. This means faster games and happier Cyber
Monday shoppers. So go check that out right here at the link in the video
description. Just try to contain your excitement. So thanks for watching,
guys. Like, dislike, check out our other videos. Leave a comment if you have a
suggestion for a future video, and don't forget to subscribe and follow.