Continuous Delivery Foundation CDEventsCon 2022, 13 Jun 2022

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Expanding Interoperability in the CD Ecosystem - Mauricio Salatino, VMware & Ishan Khare, Loft Labs

Description

Expanding Interoperability in the CD Ecosystem - Mauricio Salatino, VMware & Ishan Khare, Loft Labs

Building an inclusive ecosystem where you can connect different tools built in using different technologies and languages is hard, as different tools tend to promote different protocols and similar but not the same architectural patterns.

This presentation focuses on the CD Events initiative led by the SIG-Events Working Group at the CD Foundation. During this presentation a new use case will be presented showing how tools like Knative, Tekton and Crossplane can work together by just relying on CD Events, no custom libraries, no forced protocols, just a standard and reactive way to interconnect disparate systems that were created by different communities with different purposes.

For more Continuous Delivery Foundation content, check out our blog: https://cd.foundation/blog/

A

So our next speakers are ichien carre joyson from india uh software engineer at loft labs and mauricio salatino johnson from joins us from the uk staff engineer at vmware. There.

B

B

Let's do it. Okay, people is joining now, that's good all right, so we will be uh talking a little bit about like expanding interoperability in the cd ecosystem. That's a mouthful of things and we will be showing a demo that it's pretty interesting, it's just combining a bunch of tools uh and because it's pretty interesting, it's also pretty complicated. So we will take it slow.

B

We will try to explain what we are trying to achieve, what we are doing and then ishan is going to show kind of, like an amazing demo that he has built so the agenda. It's pretty simple. We are going to talk about like a use case that we have been using for building this demo. The challenges that we faced.

B

While we are using cd events, we are going to show a demo and also we are going to talk a little bit about the challenges and the next steps kind of like in our opinions or where should we take be taking this? Basically.

C

Okay, so my name is sean. uh I'm working uh currently at loft labs as a software engineer, mostly working on v-cluster right now and uh yeah previously worked at gojek with the platform team there. So yeah, that's mostly about me, yeah.

B

He really likes building kubernetes controllers. This is something that I found you know by working with him. He really likes it. He and we will be showing a couple of them.

B

My name is maurice salatino, I'm at salavoi in twitter. I'm writing a book. That's called continuous delivery for kubernetes. There is a discount code down there. If you are interested in it feel free to check it out, if not check my blog at salawat.com, I'm a staff engineer at vmware, I'm building k native, which is another open source project that we will be showing here, uh I'm working with the eventing side of things, which is how do we route cloud events in general?

B

And how do you connect different system using events and I'm very passionate about functions as well, something that we will be showing? Maybe at the end, if we have enough time, uh I've joined this guy like the sig events working group like a long time ago. It feels like forever andrea that I've been working with this group, uh but but yeah. I've been kind of like this person that it's not in every meeting but keeps coming back and saying. Okay, we should build this poc.

B

We should be looking into this kind of thing, so keep bothering the folks trying to you know just build new cool stuff and hack around some some cool projects, and that's me- and I think, that's the main reason why we are here, because we uh think that there are a couple of things that we need to build uh with city events, and there are like uh things that we can do for other people to adopt uh cd events.

B

uh You know in in a better way, so today we are going to be talking about like this very simple scenario: the idea of having a platform cluster that acts as like a like central platform for developers to go and request environments.

B

This is something that is becoming very, very common in the industry, like every company is building their own internal platform and they all have like platform teams in there just to build these platforms right. So we wanted to take like this complex, like this is another, this common scenario and then just start looking into how people can use cd events to actually build the integrations between the different tools that they need in order to achieve this right.

B

So again, we are going to be using this setup where you uh as a developer, go to a platform, and then you request an environment, and the platform should have all the configurations to go and create that environment. For you, you can use at least you know, 20 different tools to achieve that right, but we will be showing a very specific combination today of tools that are coming from the city foundation and from the cncf uh and yeah.

B

If you are building platforms, you probably know about how it goes, it gets really complex, really really fast. So what do we want to achieve? We want to uh allow developers to provision their own environments on demand, and uh for this we will be referencing this idea of having something that is called the platform cluster right like you, can have more than one platform cluster, but we are making reference to this place where a bunch of tools are installed, and these tools will allow you to provision new, basically new kubernetes clusters.

B

We should be able to. You know, configure these environments in different ways, depending what our developers are building and for that again we would just need some kind of automation to make that happen, and, of course, our developers will want to use those environment that were just created. So they need to have access to credentials and make sure that you know they have all the things that they need in order to connect and start working with these new provision environments.

B

And then we need to make sure that we have like clear extension points, because the moment that you tell like a developer that you need to use this tool, they will want to use a different thing. So you will need to be able to extend your current solution to support like new use cases and new. You know new requests from your teams. That will happen all the time.

B

So in order to achieve that, what we need to do is basically, we need to glue a bunch of different tools, and I didn't want to use the cncf landscape right, like it's huge and it has tons of different things that are all amazing, but they actually were not designed to work together very well. They are all different in some way. They are taking different approaches.

B

They have been designed by different people trying to solve different problems, so we need a way to glue all these things in a way that we are not too tired and we are not. You know writing glue all the time, and I think that I'm referring to this here, like in this point where what I wanted to avoid like as an engineer, is to build an intel like a point-to-point integration right like I, don't want to integrate tecton with this other thing.

B

I want to make sure that tecton can speak a common language, so this other tool can understand it right. So then, you know if you have like another tool like tool c that you want to integrate. You know that they are all talking about. They are all talking the same language and that's the main reason why we are presenting here in cd events, because we believe that the cd events vocabulary it's going into the direction of being this common.

B

You know dictionary of terms that we can use when we are talking about delivering software or, in this case, delivery, environment or provisioning stuff.

B

So we have been built a demo that it's basically using all these tools, uh and this is because we wanted to keep it simple, because this can come.

A

B

Very crazy: uh I am working for this project that is called canadian. How many people here knows what k native is?

B

Okay, we have some people that doesn't know so I will just quickly explain what it is so k native has two big modules. One is canadian serving the other one is canadian eventing.

B

uh I think that in this particular talk we are going to be showing both in fact yes, okay, so kennedy serving it's all about auto scaling and basically providing some abstraction, so developers can define how to deploy a service in a very simple way on top of kubernetes and then canadian eventing. It's all about routing events between different systems, because we are going to talk about city events. We want to route events across different tools, so we will be using native eventing routing capabilities to to move stuff.

B

Around tecton was introduced before right, like by viva as well, and I'm pretty sure that andrea also talked about tecton, but tectonics pipelines like running pipelines in a cloud-native way right, crossplane. How many people know knows about cross plane here? Okay, we have a bunch of folks, a bunch of folks that doesn't know so crossplane. Basically what it does. It allows you to define how to provision infrastructure by creating kubernetes resources.

B

So what you can do with crossplane is you can create a jaml file that basically represents a database in google cloud, so you can just write a simple. You know jumble file with some parameters saying the size of the database, the type of the database. You send that to kubernetes where crossplane is installed, and then you will get a new instance of that database running in google cloud and the powerful thing of crossplane is that you can do the exactly the same thing for aws or for usher.

B

So in this way you have like something where you can send kubernetes resources and it can provision different cloud resources in a very kubernetes-oriented way and that's, in my opinion, pretty powerful tools like crossplane. They not compete, but they are kinda like in the same space of terraform cloud and terraform in general and pulumi as well. So kinda like that infrastructure as a code kind of thing, but this takes it to the kubernetes space.

B

So if you're, using tools like tecton, where you define your pipelines using jammel or knee, where you define how to deploy services in jaml crossplane can be easily integrated with any of these tools. Because again, you can use all the same tools that you're using for all the other things.

B

So today we are going to be showing how to create cloud resources using crossplane how to route events using k native and how to build software and how to basically trigger different behaviors using tecton.

B

So when we talk about like the platform thing like the box that I showed at the beginning, we are talking about this, like it's a kubernetes cluster that have crossplane installed, it has k native installed. It has tecton installed right. So whenever, like we want to provision something, usually what we will do is we will basically trigger a pipeline. That knows exactly which tools that we need to create and which resources we need to create in order to provision. You know our development environments, all the interactions and all the you know, exchange of information.

B

We want to do it with cd events, because again we want to integrate all these tools without actually writing an integration between tecton and k, native and kne81 and crossplane, because the moment that we bring another tool into the picture, then we will just need to write another very custom. Integration.

B

For the environment, cluster side of things for the environment, cluster side of things, we are going to be using k native, and in this case it's k native serving right, and what we want to see here is that whenever we deploy a new service in this cluster that will be created dynamically in some way, we are going to be emitting some events, saying that you know that, like a new service was deployed or a service was removed here right.

B

So, if you think about this, when we interact with the platform cluster, we will be, I will be showing the flow now in a bit, but the idea is somebody will request an environment.

B

The platform cluster will create a new environment, but then, when the developer deploys a new service into that environment, we'll be also externalizing that using cd events right then we can just build like a monitoring tool that just understand about cd events, and we can see what happens from the moment that somebody requested a class like a new environment to the moment that they deployed the service into that environment that was dynamically created.

B

Why see the events and why that person there? I have no idea but cd events. I know why again, we want visibility across all these tools and the behaviors that are are being implemented. Right, like we want to see from a delivery point of view which tools are involved and the behaviors that they are executing and their responsibility.

B

We want to implement an event-driven integration approach and that's mostly because again, we don't want to build this point-to-point integrations and again. I believe that the you see the events that we have in the vocabulary today are giving us kinda, like the first version of this language that we need to expose.

B

You know all the different stages in you know: delivering software right from creating environments to actually seeing connect services deployed and, as you can see here, these things are happening across multiple clusters, but we can have a common place where we can see all these events and route. All these events, so we can just actually understand that and again the the the nice thing about like using kinetic and kinetic eventing is that they already support cloud events.

B

So cd events are supported out of the box in some way right we can send you know cd events to to canadian inventing, and these events are going to be routed and then we can just pick them up and forward them to different services.

B

So, as you can imagine, we are just going to be showing these two very big steps. First, how do we request an environment and then, basically, how we use an environment right uh so connect from two different perspectives? They're requesting an environment is like the development developer is requesting an environment to the platform. The platform is going to be doing a bunch of stuff the developer.

B

The developer will get some kind of credentials to access the environment, and then you know we are just going to be able to monitor that environment and see what's being deployed in there.

B

I will show the flow now yeah yeah, so the first thing, uh the first thing that we are going to do and again we are doing this and showing all the diagrams it's kind of like step by step like baby steps because it gets complicated and then, when we see these like in different clusters and in like in the real infrastructure running, uh we can have kinda like we can go back to the diagrams to say. Okay, now we are doing this. This is what's happening right again.

B

We have a platform cluster where which has k native eventing installed, and it has a broker there that it's basically expecting events, it's receiving all the events, then we have tekton installed and we have some pipelines configured there and the pipelines will have the steps to basically use crossplane to create and provision new environments, and even if this looks like really complex at the end of the day, it's again it's like.

B

If you look at crossplan documentation, it's just creating some jumble files here and here some pipelines that are basically going to apply those jumble files using crossplanes. So new new environments can be provisioned, as you can see both like tecton and crossplane. We have like a cd events controller here, so it's like another component there that it's running alongside the the main projects that basically understand cd events, understand how to produce and how to consume cd events to basically do something with the project right.

B

In this case, we are meeting an event here, like somebody requesting the new environment is submitting an event that detect on cd events, controller, can understand and then just trigger that pipeline when the cluster gets yeah when the cluster gets created and when the cluster gets created. Basically what's happening is that crossplane is going to emit an internal event that can be captured by our cd events controller and then we can emit another event to the broker. So in this case the event that we are getting is like this cluster is ready to be used.

B

So basically, we can just notify the platform cluster that you know what you requested is already ready, but maybe there is something else that we need to do when the cluster is ready, and the next step is basically installing some some tools right in this case. In this cluster, we need k native serving just to facilitate how the the developer will build their services, and that's only happening because we know by crossplane that the cluster is ready. So then we can go and trigger another pipeline that will install some tools in that cluster.

B

That was created, and in this case, as you can imagine, right like we just created a new cluster like a new kubernetes cluster, and in order to install some tools, we need to do some credentials handling right, like we need to. First of all, get the credentials from this new cluster just make sure that tekton has those credentials, so it can actually run some pipelines that will install some tools in here.

B

All that interaction- it's it's pretty complex, but the you know tecton, makes it easy to run pipelines and cross plane, makes it easy to create resources and great get credentials to access the resources that you created. This cluster, it's being created in gcp in google cloud and our platform cluster like each and we'll show. You now is running in digitalocean, so the multi-cloud kind of like a strategy.

B

It becomes more apparent right, like we are using open source projects to bootstrap clusters in different resources and different cloud providers, and then we are using events just to communicate this multi-cluster setup and they can be running even in different clouds and it all works which is kind of like magic. It's really exciting.

B

And finally, I guess that that's the last step that that will be showing a little bit of like the function. Side of things is like. We have now a new cluster as a developer. We got what we requested and we are going to be deploying a new function into that cluster and, basically, that can what we will be showing here is that, as soon as I deploy a new function, we have another component there in that cluster. That is, you know, looking for k native and all the things that are created and emitting cd events.

B

Like you know, a service was like in this case. The function was deployed right. That basically means that we can go back to the platform cluster and we can trigger some other pipelines to do some other things like, for example, here, like run some production health checks here right, like you know, we want to verify that that function is running correctly, so we can like go and use it for a bit or maybe just warm it up for for our end users.

B

So in this case like we are just having automation again even being triggered by, like you know, the the environment cluster that we just created and as you can see for that, we have another controller there. That understands how to monitor. In this case, k native and how to translate that into cd events and how to emit that all this configuration and all the wiring is automated and it's happening because we have full control on the things that we are creating and uh yeah, and because we have the right controllers in the right places.

B

So I think that issue now is going to show this flow exactly like in the cluster, and we will be analyzing like the different. You know, parts of this demo good go for it.

C

So, to start with, uh this is our digital ocean cluster, which is the platform cluster and I'll just uh go through the tools that we have on this.

C

B

You can definitely make it bigger yeah.

C

B

You make it bigger, yeah. Okay, there you go is that okay, yes,.

C

All right, so so we have, we have uh the cross plane system itself cross plane installed. We have k native eventing installed on this, and courier is also part of it. And next we have the tecton itself deployed here and I can show you the tickton dashboard that we have and uh we basically have uh one broker on takedown, and I think I just need to forward it again.

B

Access last one yeah yeah, that's all right.

B

C

Let's put forward, it should work.

B

It is loading, yeah. Are you connected to the internet? There you go.

A

C

B

As you can imagine like yeah, there are tons of things going on there, so this can all fail, but that's the normal thing.

C

B

There yeah it's showing.

C

Here uh so we have three different triggers for techton one is for creating the cluster itself. The second one is for installing k native on the newly provisioned cluster and the third one would be that would notify once we deploy a k native service on the provision cluster. That cluster is going to call us back and call us on this pipeline to print about some information about it that it's ready, and so the way we uh started is basically I'm going to trigger a cloud event uh to start with. So.

C

C

Okay, so we have received a cloud event, so so we have this cloud event trigger a pipeline that is going to actually create two resources and those two resources are basically a cluster and a node pool, and these are going to be created on gke and, as you can see, crossplane has now started provisioning. These clusters, uh this cluster for us and uh basically I can show you on the dashboard refresh there.

B

C

We see we have the workload cluster starting to get provisioned, and the next thing is, as you can see in the logs here, we have a cd events, provider controller, which is basically a cross plane, controller which we have integrated with uh cd events sdk, and it's managing this uh or it's basically watching this cluster crd that we just created in the platform and it's waiting for it to turn ready as soon as it turns ready.

C

It's going to emit another cloud event that is going to get caught by one of our triggers and it will trigger another pipeline. That pipeline is going to deploy k native to the newly provisioned cluster. So uh it is going to take some time.

B

Yeah, as you can imagine like, creating a new cluster live it's going to take like five minutes or so in gk. Sometimes it takes a little bit longer, but.

C

Hopefully we have used smaller machine sizes to help that yes, so yeah. In the meantime, I can click an issue.

C

So we have one of the pipeline resources, that is the kit repo that is being used for this whole demo and there we have the the cluster and the node pool yamls that we are picking up from and the tasks as I've already showed.

C

You guys that we have the first task, which already has been triggered, and the next will be the install k native, which should be automatically triggered by our cross plane controller as soon as the cluster is ready, and uh once we have that it is going to install uh basically the entire k native serving and uh deploy our custom controller on that cluster. Yes,.

B

Can you show the like the cross plane resources because for people that doesn't know crossplane, you know like creating a kubernetes cluster using a jammel file yeah? So not crds in this case are going to be resources because the crds are the ones that define what the cluster is. In this case, you are going to be able to see what a cluster resource looks like and again, in this case it's like a gcp gke cluster, but the you know the eks cluster for aws should be pretty. It is pretty similar.

C

So we have like two things in the cluster. I can show you one is the provider itself.

C

It's a bit slow, the internet here.

C

Yeah, so we have the provider gcp itself, which is the google cloud provider very similar to how tech terraform works. Where you have the core uh terraform and then you have a particular platform provider. In the same way you have cross plane core and then different providers for different clouds. So we specified a provider gcp and we have some configuration for that provider and the secret configs for our gcp account specified in one of the secrets, and the next thing is the cluster and the node pool that you see here.

C

So the cluster is here where you specify very basic things like the location when you want to have logging and monitoring enabled there are lots of other options as well, and another interesting place is that once the cluster is created, where crossplane should write the cluster credentials to for the developers to use.

C

So it's going to write it in a secret which will be named the workload cluster credits and the default namespace and another configuration option is the node pool itself which kind of machines you want for this cluster and like tons of other options, we have just kept it down to minimal and yeah.

B

So if you, if you want to extend this demo, I like to create clusters in aws or in azure. The only thing that you need to do to the platform cluster in this case is just to install the azure or the aws provider for crossplane just configure the credentials basically, which which accounts. Do you want to use to create resources and then create like a couple of more jamuns? You know like another cluster jammu or another. You know known pool jamul for for these providers and it's pretty much the same right.

C

Just just add provider azure and.

B

It's not ready yet yeah.

B

Well, the problem. The problem is that like, when you use kind it's running locally right like and creating kind of like a dynamic kind cluster, it it's messy and you cannot use cross plane, which is fun, but it's good because at the end of the day you have like a real cluster, that's ready for you to use, and then you can connect and install like real-life tools. If you try to bootstrap like two clusters in your computer, you're, basically dead, yeah. Okay.

B

So if you click there, you should be able to see the status right like what is it doing there? You ah it's almost there. It's.

C

B

It's almost there, that's cool, so the next step that you're going to show. Now it's.

C

Ready, okay, now it's ready the controller saying the cluster ready. That's our custom cross, plane controller with cd events integrated and it says cloud event has been triggered, so it should have triggered our pipeline on the tecton dashboard. So if I see the task runs, if I refresh this, oh one, second, because I think I know why.

C

We have a auxiliary config map to create a break. It's kind of that's.

B

C

So since I ran this.

A

C

Just give it a couple more seconds: it should reconcile.

B

Yeah, that's good, remember that, at the end of the day, you shouldn't be like us like again like as a developer. You shouldn't have access to any of these. Things like this should all happen in the platform cluster, and I think that what we will show later on is like basically how we connect to this cluster without like knowing how it was provisioned.

B

Reconciling there you go reconciled.

C

Config map is updated and there you go so, as you see, another pipeline was triggered by the controller with uh install key native. Now, there's a lot of steps there that it does, but basically, at the end of the day, we should see k native serving deployed up to here, and then we have our serving controller with uh crds.

C

For I mean with integration with uh the cloud events sdk and the last step would be uh installing the controller itself and.

A

C

Next, we can show probably a key native service deployed and getting some feedback back again into tecton.

B

That's a that's the idea right, but we still need to wait for those tools to to get installed, and I think what is important to to share here. Besides, the fact that we're installing k native is that this is where you're going to configure your environments and define what your teams needs to have in their cluster instead of, like you know, instead of like giving them a plane cluster, so they need to install their tools right here. You can start building all that.

B

You know platform approach where you said: okay, for my teams that are doing these kind of things, we can just install a bunch of things for them, so they just can have them there and just use them and usually the process of provisioning. This is like 10 minutes, like you know, eight minutes and there you go right.

C

So, as you can see, we have k native serving installed and everything is ready for us. So probably now what we can do is like we can.

B

Yeah, I can take a look at that and just do that.

B

Yeah, so what what edition is doing now is getting the credentials for the clusters that we just created right, like this cluster didn't exist 10 minutes ago now it does exist, so the developer should be able to connect to that cluster and now and start building and deploying the services right again, based on all the interactions between all these tools that we have used to create that environment and install k native in it, uh we should be able to have, like you know, a track record of all the cloud events that we have used and all the cd events that were used there.

B

So as part of this demo, some of the events that we were like consuming from the cd events point of view was, you know, like environment, created, uh yeah environment like ready and all these things and and then now we're going to go into the developer side, where you can like deploy new services and then just see them as well in the same kind of level of abstraction.

C

Okay, so right now we don't have any k native services.

B

Yes, this one yeah perfect, so basically, what I'm going to do now is I'm going to use something. That's called genitive functions just to create a very simple service like a very small application, and I'm going to push it to this new cluster that we just created right and, as ishan said like. There is nothing running in that. You know in that cluster because we just installed like we just created, and we just installed some tools, but there is no application running.

B

So uh can your functions basically, what what allows you to do is to create functions like from the moment that you create, like a small small application to the moment that you deploy it uh just using a cli. So what I will create is like a cd events, con function and I'm just creating a directory, I'm going into the directory and then I'm using this cli tool that it's called func to create a new function project right like so.

B

I can basically create functions in any language that I want and I use the cli to just basically create the structure of the project. So if I use font create and then I will just create a go function here, just using language go, you can use java, you can use rust, you can use node.js and I will just create a function that I can call using an http request right. So I've just created a function and a function is a very simple project. Again. This is a very simple, very common.

B

uh You know goal project and I can show you here how the function code looks like in this case. It's just you know the template for a function that basically tells you like. Here's, where you write your business logic and it's actually just returning okay now. So let's change that and I would just write something hello from cd events con right. So that's kind of like a very simple function that every time that I call I will just get that back.

B

uh Funk also is focused on the developer. Experience right, like the idea here, is that if I just want to create this project and deploy this function, I don't actually need to build a container or write any jamal file against that cluster. So what I can do is, I can do func, deploy and func will take care of, building and containerizing this project for me and then deploying it to the newly clustered, the cluster that we just created.

B

The only thing that it's asking me for here is like um is that all right there you go? Is that all right yeah? So the only thing that it's asking me here is like the docker register, like the the username in docker hub that I want to use to push the container to and that's his username, basically because we have his credentials here in this computer.

B

So what we will see here like at the at the top here of the screen, is basically func cli, in this case it's using a project that is called buildbacks to detect the language that we have used for creating our function and it's going to start building that container for us. So it's just going to be on the container. The next thing that it's going to do is going to push that container to docker hub. So then we can have so we can download that container into the cluster.

B

That we just created and just run it in there right, so we will need to wait for a bit right uh until that gets built. I realized that this is something that is open in the community each and here has like an apple m1, which has a different architecture to build. You know, containers so uh and the way that we are building this image is it's like. It will need to cross, compile right, because in the cluster that we have here that we have created, we don't have that kind of like cheaper architecture.

B

So we need to create like an image in an m1 computer, for you know for like an amd cpu in the other side. So it takes a little bit extra time on doing that, but that's kind of like something that it's been reported already and we are working on making sure that that's fast the whole process, the first time it takes like around a minute or something a minute and a half uh because of its m1.

B

It might be a little better, but you can see here on the top right something just pop up, and now we have a service running in our cluster that we just created and the url. I should have a url, it's funny that the the service is there, but this is still like not returning, but at the end of the command line tooler I like that, still building and deploying stuff.

B

Yes, there you go now we have a url which basically means that we can just interact with that function and basically, what I'm doing is I'm executing an http request.

B

Against unfunction and double click. Yes, if I do a double click, it will copy yeah. Yes, sorry about that. There you go so I'm just calling that function and I've just called the function that I've just deployed. But that's we're not not the last thing that we want to show. We want to show that because we deploy something we.

C

Can get notified, we have the class the service deployed and ready to be consumed.

C

We had a k-native serving controller integrated with cloud events and when we deployed this controller we also told it through a config map that, where can it send the cloud event back reporting about successful deployments of k native services, so that would be our platform controller uh platform cluster, so that were would be in techno dashboards. If I go back to task runs, it says: display k native service successfully deployed, and if you see the message it says default.

B

C

Name that we used so default namespace and the service name and was successfully deployed and like it can have all kinds of metadata about the service and.

B

Yeah and again we are showing here that we can integrate things. We can get information back from the environment that we just created using this common language, these cd events that basically are notifying that you know things were delivered in our environment, so then we can trigger pipelines to do any kind of runtime tests or performance tests against the stuff that are being delivered.

B

One thing that is missing from this demo that I think that we can improve definitely for the next time that we do. This presentation is to show you in a single place all the events that were emitted, so you can see from the delivery point of view what happened since the moment that we requested the cluster to the moment that this service was delivered. But I think that you can get the idea that that, at the end of the day, we will have full traceability across.

B

You know different environments, about what were the things that were happening, switch back to the presentation right. Where is it.

B

There you go yes, so we wanted to close the presentation and we're almost out of time, so we will just go pretty fast with some of the challenges that that we faced when we were trying to build this demo, and I think that obviously, like routing events across multiple, you know clusters, it's a complicated thing doing that in a secure way, it's even more complicated with certificates and all these things, because you need to provision all that infrastructure.

B

It can be done, but we haven't gone through that. Yet uh another thing that it's really important for me to highlight in this presentation is that each and here build like two controllers, like one for k, native and one for crossplane, which basically are doing this translation between the tool itself, crossplane and and k native and cd events right and that's kinda, like the way that we think that we should be integrating with other projects for this demo.

B

We also use the cd events integration from tecton as well, which is really nice to have there, because now pipelines can be. You know speaking the same language we haven't showed. You know like captain integration in this demo, but we have the old plc that it's also using captain and it's pretty nice. But when you look at this, it's like each project will have its own way of integrating and doing the translation with cd events, and each project will have a different way. Even if this is all like go, they all use different libraries.

B

They all these using different approaches like even you know, it's like it's funny like you. You need to build two controllers. They are completely different, like in nature like it's like. Oh what, and if you look at the captain integration, it's even more challenging because it's it's like two different components that you need to build.

B

So I think that there is a lot of opportunity there just for a project experts to just provide this integration out of the box, and I think that, like this sig event, we can just help them by building more sdks and more tooling, so they can build these integrations in a simple way. We know that the java sdk is coming and we are going to be working more on the go.

B

Sdk, so that's kind of like a lot of work that, if you're interested in helping out like building an sdk for cloud events, it's pretty cool and it's pretty it's not very like advanced, but it's very important.

B

uh We also kind of have a couple of discussions there in the group when we were building uh this about emitting events. We are closing yes and a meeting event, so I think that that's kind of like something that we need to keep tracking on uh there are other tools check these tools. If you're interested like captain is one of them, graphics is another one, and cartographer is another tool that you can use to implement the scenarios that we were showing today.

B

There are some links in there. We will be probably tweeting about it and sharing with the organizers. So you know you can always check the links later on and I think that's pretty much it man yep. Thank you very much. That's my book isian. Thank you very much.