Cloud Native Theater | Cloud Native University: Introduction to GitOps - Chris Plank, NatWest

In this session, Chris Plank discusses the evolution of data transfer from physical mediums like floppy disks and CDs to modern cloud-based solutions. He shares insights from his 30-year career in IT, highlighting key developments in networking and the shift towards cloud computing, DevOps, and Kubernetes. The talk emphasizes how tools like Git and containerization technologies, including Docker and Kubernetes, have transformed software development and deployment practices. Plank introduces GitOps, explaining the role of Flux and Argo as popular GitOps controllers, which enable declarative management and continual reconciliation of Kubernetes clusters. He concludes with resources for further learning about GitOps and shares links to relevant training materials.

Uh, I'm Chris Plank. I'm a CNCF platform engineering technical community group leader and I work for uh, one of the top four banks in the UK. And I think you can guess where I come from, right? Which country? Um, I'm notorious for going over time. So, we'll have a bit of a laugh today. It's only 25 slides, Daniel. Should be fine. Uh, but let's see how this

goes. We're going to go really, really fast. Really simple topic. I've been IT for 30 years. Think of me as a bit of a dinosaur. So, this talk's going to be full of dinosaur prints and it's going to be full of dragons and tales of old. But I'm not going to talk about mainframe punch cards. If you want to find out about that, there's a QR code

there. You can go and follow it. But this is really a story of how we got to get ups and what get ups is. And it did start back in those mainframe days. You know, people used to take data and input into servers and mainframes and things like that. So, we're going to go from floppy disks all the way through to get ups. And really the story's

all about humans physically moving data to servers, right? And how we how we used to do that and what we do now in the kind of cloud era. And we went from floppy disks, we went to CDs. And CDs obviously took a lot more data, but it was still physical. People were still doing physical stuff and going into the data centers. Then we moved to even smaller

but more capacity devices, the USB sticks. Again, more data but still physical. Then the internet came along. You know, I started my career in 1995. And when I started it, it was like the dial-up era, you know? Tales of old, you have to plug in your phone line into a modem and hear these weird sounds. And the networking was terrible. Then we had 64K. Could you imagine

how long it would take to upload some of our docker images today over a 64K line, right? Be forever. Uh, so tales of dragons to the left. I'm not going to talk about everything before 1995. But if we go through that timeline, the things that started to evolve, we got ADSL, we got better connectivity. The CSPs came out. We started getting direct connect connectivity into AWS, for

example, and then to Google. And we got faster fiber optic. And I work for my RV, my motorhome. Um, I think I can't remember what they call it here. Uh, camping car. Uh, and I use Starlink. You know, and we've got fantastic speeds coming through Starlink now as well. 120 meg downloads and 80 meg uploads. Uh, way, way better than those old dial-up eras. So, kind of

focusing on that era of the 2000s onwards really, when the cloud came along, devops came along, Kubernetes came along. There's a lot of exciting things happened then. with the increase in kind of network connectivity, people stopped doing things physically, locally. They started moving things to data centers that were network connected. Uh, a lot of the developers started taking more control of things because they didn't need to

get into these controlled environments. They just had access that they could deploy things to. So, we had a shift left culture where everything uh, uh, kind of moved towards development organizations. The devs did building, testing. They were deploying applications faster now. They're able to do things a lot, lot quicker. They started introducing version control practices. Tools like Jenkins came out. Cloud, as I mentioned already, came along.

So, they started using kind of cloud computing. Git was released as a better tool for doing all your version management and things like that. And lots and lots of tools started to evolve. And I we're not going to talk today about all the development and operations boundaries, right? But dev and ops eventually was about development and operations working better together rather than just throwing it over the

fence. Uh, so the devs were starting to use Git. They were starting to use infrastructure as code. They were starting to do Terraform. They were building and maintaining their environments themselves. The boundaries got a little bit blurred. Sometimes it was a bit fractious with full stack developers. And we ended up with really high cognitive load. And the devops model was kind of a push up hill model,

right? You know, you're trying to push that big boulder up a hill. There's just a lot of things that you had to do uh, in in that push model. And then along came Docker, along came Kubernetes, along came Helm. So, suddenly we had these lightweight virtualization containers that we could quickly store somewhere and use with a package manager that made things easy to kind of template, put

in some variables and apply it to lots of different types of environments. And we had a brilliant scheduler that took care of the high availability, um, keeping things running so that there wasn't as many humans having to do that. And so, devops and Kubernetes, to me, it's really simple. You got a bunch of developers. They put some stuff in Git. They do some testing through their CI/CD

pipelines. They do some sort of build. They push it to a container registry. Now, they can change that pipeline now with the pipeline tools. So, there might be lots of steps. This is just a simplified view. And then eventually that thing that they've built, they push that through into kind of the deployment world where it goes into a container registry, there's some sort of deployment pipeline using

Helm, bringing in secrets, bringing in all sorts of information that fills in a template and ultimately deploys to Kubernetes. Cuz using manifests in Kubernetes is actually raw, quite difficult. So, Kubernetes got a lot better. These things called controllers came out. These things called custom resource definitions came out. Controllers kind of give a control loop which watches the state of the cluster and then it make the request

changes where those are required. And CRDs, they're just a way of extending the Kubernetes API to define your own kind of resource types. And then you start using them to do some really cool things. And some of those things were the really cool GitOps controllers that came along. We started to get a declarative model where controller driven convergence would happen. So, really, really simply, someone would kind

of put something in into Git. Something is running in the in the Kubernetes cluster watching that. And it'll just reconcile that. And it'll do it all the time, you know, periodically. So, if something changes in the cluster, it'll redo it. And there's a lot of new features and things that we can do, but that's the really, really basic thing. And the the kind of two most popular

products that are out there, Flux and Argo. You'll hear everyone talking about those. We had Flux Con, I think we had Argo Con yesterday. And already all the videos are online. So, go to the CNCF YouTube channel, you'll see all of those is a pull model. So, we've still got the developers. We've still got Git. We've still got the testing. We've still got the CI/CD. We've still

got the container registry. And they're still doing all that sort of stuff. But then you've got Flux and Argo, as I said, running in the cluster, continually reconciling that. And it's a really simple view, but you can make it as really complicated as you like. I've got 1 minute left. I'm almost there. It's the more info slide, the very last one. So, that was just a quick

overview from me. If you want to know about GitOps properly, there's the free CNCF uh, learn sorry, Linux Foundation uh, training course on this. Um, there's loads of good free courses on the LF education site. Use them. Uh, and on the other side, two of my colleagues presented at Flux Con Uh, as I say, I work for a bank in the UK. The guys did the presentation.

It's fantastic. Two Jedi out at the front. The QR code there is for their talk as well. And there's lots of the Flux Con uh, talks there. I'm a Flux guy. I'm not an Argo guy. thanks very much. I was Chris Plank.