 Hello, we're so happy to be here. What a gift. Yes, we are here to have some fun. So are you here to have some fun? Let's have some fun. I'm gonna have some fun. Imagine you're the developer in this diagram and you work at a company that provides a very important software product Rainbows as a service Now your project your company is dominating the rainbows industry and it wants to stay on top So we've commissioned gardener reports who put together a think tank of all the industry thought leaders and we've Identified the next big trend in the rainbows industry. Do you want to know what it is? Because I really want to know what it is with me. Tell us it's spiders what what I think spiders are literally the opposite of a rainbow So anyway, you're the developer in this diagram And it's your job now to add the spider to the rainbows and push it to production And when you do that your changes immediately live in front of all of your company's end users This is scary, and I'm not just talking about the creepy spider here This is scary because if you slow down if you if your application has problems You can slow it down and cause problems for the end users or worse You could be the cause of your company's most dreaded fear Down time These are high stakes. Well, well, well why causing downtime or frustrating your usage is something that you should try to avoid We need to agree that this diagram here is a drastic over simplification of what happens when a developer pushes code Okay, okay. I'll give you that it's an over simplification How about this that's a little more accurate wouldn't you say it looks a little better? Where is the developer there? Oh, okay? The developers way over there on the left reductions on the right But don't don't worry if you don't understand everything that's going on in this diagram In fact, don't worry if you don't understand most of what's going on in this diagram The point is for us to show you that it is a lot It is complicated and it has to be complicated when you're building complex Distributed systems that are meant to scale across millions of users That's true. And the question that we are asking and trying to answer doing this presentation Is how much of this entire landscape? Do you need to actually understand in order to be efficient at your work? So to begin to answer that question, let's talk about Kubernetes By by using Kubernetes and the power of the Kubernetes API's Companies have a clear separation between infrastructure and application development teams Infrastructure teams can focus on provisioning hardware and VMs if they are working on premise or choosing their favorite cloud provider As most of these cloud providers already support the Kubernetes API's on the other hand application development teams Have a very powerful API and declarative API to deploy the workloads no matter where that infrastructure lives So that's a good thing, but we need to agree that this is yet again another drastic over simplification of what happens Well, it's very helpful that application teams now don't have to deal with the infrastructure directly There are still some challenges for one It can be a challenge to train big teams to use Kubernetes And let's be honest not every developer wants to learn how to use Kubernetes Another challenge is that there are so many amazing projects in the CNCF landscape And it often falls on developers and application teams to research these projects and figure out how best to extend their Kubernetes cluster for their particular use case and our application team needs to be writing code They should be thinking about adding the spider to the rainbows application by the spiders spiders So welcome the heroes of our story Platform teams more larger and mature organizations that have been have been working with Kubernetes for some long time Are starting to create platform teams to build platforms on top of Kubernetes They do that by trying to understand what those application development teams need and try to hide all the complexity of Installing managing and operating these tools putting everything behind a very friendlier platform API This platform API can be used by application development teams to self-service to have access to all these tools and things that they Need to work using a self-service approach But what a friendly friendly API I want to invite them to my birthday party. You should I hope they say yes Okay, so the platform team Starts to build the platform first by collaborating with application teams. This is a very important step They need to deeply understand the tools and processes that the application teams are currently using and what those pain points are Then they can figure out the best way to help and encode that knowledge into our friendly friendly platform API That then the application teams can access in a self-service way So for example our application team needs a development environment to be able to add the spider to the rainbows application so our developer asked the friendly friendly platform API for that environment and low and behold Without any human intervention that environment gets created and it has a speedy spider cache and the spider database Not only that but the environment comes Pre-configured with security and governance policies that the application team doesn't even need to worry about there you go And this takes us to our first demo of the presentation where we are going to interact with our platform APIs to request a new development Environment so what we have seen here in this recorded demo I would I would love to do it live, but I couldn't so basically I'm part of their acne team And what we are doing here is we are going to request a new environment And we can do so by sending a request like this which basically we have extended the Kubernetes API to understand about environments You can select the type of environment by setting a label and also then as you can see they're Setting up some parameters that are very very specific to the Needs that I have right like in this case having a spider spider database or a cache You can see I'm sending like this request using Qtl because it's a Kubernetes resource And voila the platform just created an environment for me. You can actually run this demo live We will share some evidence later on Because it's a Kubernetes resource you can query all your environments using Qtl or any other tool in the Kubernetes space And then you can see there that the environment is not ready yet But we will use this environment in our next demo and we will deploy some workloads into that. Yep Excellent. So what we just saw was Mauricio interact with the friendly platform API and behind the scenes that platform API use crossplane and helm together to create that development environment that development environment is an Isolated virtual cluster made with the cluster and it has k-native serving Pre-installed into it. The good thing about these things is that you don't really need to understand how crossplane helm K-native or big cluster works because that's the whole purpose of having a platform API platform team Creating these platform APIs that allows us to send a simple request to create a bunch of things for us Excellent. So we saw how the platform team can help application teams provision development environments in a self-service way But platform teams can also make the developer experience better by providing more widely scoped tools That for the application team makes the right thing to do the easy thing to do So for example, they could create templates and quick starts so that Developers can start their projects easily and by following company policies right from the beginning They can also curate maintain and continuously patch tools like cloud native build packs that automate the way application source code gets built into a container images and Finally the platform can provide a catalog of ready-made solutions that application teams can then extend So solutions like tecton pipelines or helm charts and that takes us to our second demo Right and we're going to basically create and deploy a function using a project that it's called k-native functions Into the development environment that we just created So we are what we are going to see here in the demo is that we are going to first check that our environment is ready to Be used that's why we run that command. It is ready and now we are going to use big cluster connect because we use big Cluster to create the cluster so we need to connect to it and now we are in our environment We can use it we can do whatever we want in it and what we're going to do is we are going to create a new function again Using this k-native function functions project for that we could go into separate directory We create our function directory called a spider eyes because we want to bring some spiders into our rainbows And then we use this command funk create Pointing to a repository that contains some templates in this case We are using a template that it's called spiders and that allows us to bring all the things that we need to draw spiders on top of Our rainbows once the function is created in this case using the go programming language We can change the code we can modify it anyway We want but we don't have time for that now So we are just going to deploy it using fun deploy when we run funk deploy This is using again this project that it's called cloud native build packs to transform the source code of the function Into a container image so the developer doesn't need to worry about how that transformation happens And it gives the platform team the ability to create how that process works By the end of this command We are going to get the URL down there in the screen where we are going to click and we are going to see our Function deployed in our environment. So if we click into that link, we should be able to see that now We have a spider and a spider on top of our rainbow in our development environment. So trendy. It's pretty pretty I feel so cool right now So what we just saw is Mauricio connecting to the development environment with B cluster connect commands And that environment already has Knative installed into it So Mauricio could immediately use the funk CLI to create and deploy an application without any Docker file Or any YAML and the platform and platform team helped enable this sweet sweet developer experience By not only providing that development environment But by providing templates to get started in a quick and easy way and then providing build packs to automate the build of Source code to container image in a company happy way Okay, so we saw a couple of ways now that the platform and platform team can improve the developer experience and the development life cycle But now how can the platform team help that finished application find its way to production? Do you mean that we cannot push spray to product? Sorry, Mauricio developers under no circumstances should be pushing straights of production Instead we're gonna rely again on our heroes the platform and platform team This time they're gonna provide tools and best practices to help that application find its way to production So in this example, we have a get-ups approach to do that So we have the production environment configuration stored in a get repo and we're gonna use a get-ups tool like Argo CD And Argo CD will watch that get repo and if any changes are made they're gonna sink that change to the production environment So then when our application team is ready for the spider eyes application to see the spotlights They submit a pool request and then automated testing happens And when all those tests are green the pool request is merged Argo sees the change in the get repository And then the application is deployed. There you go So let's see that in action and for that I will walk to my computer to try to do something It will never work, right? So we are going to take our function into our production environment And our production environment is actually rainbows as a service.com So if you go to that website, it's actually working there And we have configured this production environment using a get-ups approach as we've mentioned And we have this repository called kube-con production in my github account where we are configuring the application using k-native serving here That's why we have a single demo just to configure the entire thing So if we want to apply changes to this application again as we've mentioned We will have a pool request with those changes in this case We want to add the spiders modifications that we just created This is where the platform kicks off right like this is where we need all the validations to make sure that these changes will actually run in our production environment So performance test integration test all the things that you need to do will be validated here when this is ready We can actually merge this pool request to apply these changes into our live environment So that's exactly what I'm doing right now So if you access rainbows service a bit ago now you can access again Because as soon as these changes are done and these changes are synced we should be able to you know see All the changes applied into production and if it starts true I should be able to refresh here in my production environment They're in the screen and there we go. We took out the spider from on development to our production environment. Hey Thank you very much Leading edge rainbow technology. We got the spider rainbow tag on Twitter is trending so hard right now All right, so to recap the whole demo First we use that friendly friendly platform API to prove a self-service provision a development environment Then because KD is already pre-installed into it We use the KD to funk CLI commands to get that spider the crate and deploy the spider eyes application With no docker file and no yaml Then the platform and platform team helped our application find its way to production in a safe and automated way So Whitney, what do we want people to take away from this beautiful presentation? The big thing to remember from this application is that platform teams exist To manage all the complexity of getting an application into production and this frees up Application teams to do what they do best, which is to write code so specifically Platform teams do this by collaborating with the application team to understand what they need and what their pain points are and then to To add that knowledge into the platform API where the application team can access it in a self-service way the platform team It also improves developer experience by encoding things like best practices architectural patterns security and governance policies into the platform team into the platform itself so that the application team can access doesn't even need to worry about it and Finally the platform and platform team helped to automate the path to production in a safe way So the bottom line here is platforms and platform teams are there to make application development teams happier and more efficient And they will take care of taking all the changes and all the cool features that they build safely into our production environment So one more thing before we go There is that GitHub URL there where you can actually run all these examples in your laptops or in your Kubernetes clusters I strongly recommend you to play with these technologies and see how this work and that's what we got