1:14 Introduction & Welcome

1:14 Hello, and welcome to today's episode of Rawkode Live. I'm your host, David Flanagan, but you may know me as Rawkode. Go figure. We've got a really cool episode today. We're taking a look at a tool to help make your Kubernetes lives easier. Who doesn't want that, right? We're gonna be taking a look at Lens from Marantus, but before we do that, we've got a little bit of housekeeping. So I say this every week. If you're not subscribed to the channel, now is the time to do so. Please subscribe and click that bell. You will get notifications for all new

1:36 Housekeeping & Channel Updates

1:50 episodes of Rawkode Live. I'm gonna do my best to produce materials to help us navigate this vast cloud native landscape together, and I would appreciate you joining, engaging, chatting in the comments, and having some fun. We also have a Discord server. Feel free to join at rockload.chat. There's nearly 500 of us in there now talking about all things cloud native and Kubernetes. So come and say hello, and I look forward to meeting you. Also, there are Rawkode membership packages from as low as 99p per month to support this channel, and also there is incubating and graduating levels.

2:21 Incubating is for people that wanna join us and do live courses and workshops. Currently, are working through a course on influx DB two. We had an episode today where we explored the Flux language and how to query time series data. I wanna thank Kevin who signed up today for incubating level and Noel who has already been in there, and there's a few other of you. Remember to join the Discord and connect your YouTube Alright. That is the housekeeping done. We are going to meet Edward from the Lens team at MERANTIS. Hey, man. How's it going?

2:44 Guest Introduction (Edward from Merantis)

2:49 It's going well, David. Thank you. Thank you for having me today. How are you? Very well. Today has been a good day, and I'm excited to to play with Lens. I always like it when I get a tool that I played with and I enjoy and then get to learn more about it today. So this is gonna be an awesome episode. Awesome. I'm looking forward to it. Do you wanna take a minute and just for anyone who's not familiar with you and Mirantis and Lens, just give us a little bit of an introduction, please? Absolutely. Absolutely. So first off, I wanna thank

3:16 About the Guest & Role at Merantis

3:18 you for having me here today and the audience. Hello. I'm Edward Ianell, and I'm part of the team. I'm specifically on the product team, and I'm focused on open source technologies like Lens and k zero s, which is a lightweight Kubernetes distro. And, more of my day to day responsibilities is really seeking out the pain points within Kubernetes and other cloud native technologies to help and try to streamline developer and operator initiatives when working with these technologies. So, that's my main focus, and Lens is something that I actually stumble up upon prior to even being a part of the Lens

3:55 team while I was at Marantus. And we acquired, the Lens and the team of Lens, back in August of last year. And I was using the tool before we even acquired them. And once I, we acquired them, I was begging to join the team actually. So this was something I wanted to do quite a lot, and this is how I got this cool little Lens hoodie, which, people are able to get if they would like to join our Slack channel. I'm always giving away free hoodies. So again, David, thanks for having me. Looking forward to this wonderful session.

4:28 Awesome. Great. Introduction. Yeah. People get in the Slack channel. Get yourself a hoodie because those are pretty sweet. Alright. I believe you're gonna start us off with some slides to talk about what Lens is and why people should be interested in it, and then we're gonna do a hands on demo. You wanna Absolutely. Get your screen up and we'll kick this thing off. Sounds good. And let me know if you can see my screen. Yes. I see the Kubernetes IDE five. All yours, Edward. Awesome. Well, again, thank you, David. So hello, everyone. I'm looking forward to this awesome

5:03 Presentation: Session Plan & Lens Overview

5:06 session. And as David mentioned, we will be doing two things. One, we'll take a look at these slides. It's just an overview for us to get a better understanding of what Lens IDE, some of the features that are within the IDE, and why developers or operators should be utilizing this open source technology. From there, we'll transition into a live demo where we'll go through the key features, as well as what a developer may use Lens for, an operator may use Lens for, an SRE may be using Lens for. And then after that, we'll actually take a look

5:38 at something that's quite cool, and it was released with our newest release, which is Lens five. We released that back in June of this year, and we'll be taking a look at how you can share access to a Kubernetes cluster securely through Lens Spaces. So that's another exciting thing that we'll be taking a look at today. So without further ado, let's jump straight into it. I know this is going to be a jam packed session. And, thank you all for joining us today. I'm quite excited about this one. So we can skip over this slide. We

6:12 already talked about it, but, again, responsible for growth and developer relations here at Orantis. We'll skip through this slide. So I'm sure we all know this already, but I'll just touch on it a little bit. Kubernetes is quite challenging. People, organizations invest in Kubernetes and other cloud native technologies, but they may not be seeing that return on investment that they should when working with containers or Kubernetes. This is kind of where Lens comes in. Lens is a 100% open source technology. That's a developer friendly desktop application meant for all of your Kubernetes needs. It works with any certified Kubernetes distro,

6:21 Presentation: The Challenge of Kubernetes & How Lens Helps

6:49 whether that is GKE, EKS, k zeros, k three s, mini queue, and so forth. I did wanna bring some stats up. The these are roughly a month old or so as you guys can or two months old, actually. But we are the self proclaimed, and I I like to mention that we are the self proclaimed world's most popular Kubernetes IDE. Currently, on GitHub, we have 15,000 GitHub stargazers, which is a fantastic achievement from the team. And I do want to thank the community for this. We cannot be at this pace and at this level of, GitHub stargazers

6:59 Presentation: Lens Community & Usage Statistics

7:28 without the amazing cloud native ecosystem and the community that we're all within. We also have 250,000 users that are using the the tool itself, and we have roughly 80,000 people using it daily. And we've seen over a 60,000 different clusters in the last thirty days, and we always have some telemetry to be able to tell us, what type of clusters people are using. So before moving on, into the demo itself, where you are going to take a look at the features at a glance, I'm going to talk to these slides. I do want to mention that these

7:56 Presentation: Key Lens Features at a Glance (Slides)

8:06 are just some of the features that we will be presenting in the slide deck itself, but we'll be taking a look at many different things that, you can do within Lens once you have that desktop application downloaded and installed on your operating system. Excellent. So the first one is a unified catalog. The unified catalog should be thought of as a cloud native directory, at least that's what I like to think of it as, where you can bring your clusters, your services, your workloads, tools that you may be using in one beautiful place, which makes it a directory. Users of Lens

8:24 Feature Deep Dive: Unified Catalog

8:43 can actually very easily filter between these different resources and, assign labels to these resources to really easily recall what type of resource that particular asset may be, whether it's a Kubernetes cluster or a new Lens space or a web link, and so forth. And we'll touch on some of these things actually in the demo itself. So that's the catalog. I think of it as a cloud native directory. The next thing are two very useful things to improve efficiency when working with Lens and Kubernetes, of course. So the first is the hotbar, which is going to be on the left

9:12 Feature Deep Dive: Hotbar and Command Palette

9:24 hand side of the Lens desktop application, and this should be thought of as, like, the main navigation of Lens. And what I use the hotbar for is to really create specific workflows within my environment within Lens. I can have different spaces, and spaces are, collaborative spaces where you can add Kubernetes clusters to and share that with your team. Talk about that more in a second, where I can add my clusters to the hotbar itself. So I can easily navigate from cluster to cluster regardless of the Kubernetes distro. And, we have the command palette, which is, another

10:00 great resource to work much more efficiently within Lens. The command palette should be thought of as or it is keyboard shortcuts to perform specific actions. Right? So for example, adding a cluster to Lens, viewing viewing a specific pod when you're within a cluster, you can use a quick shortcut to be able to actually access this particular item or feature or whatever you may be doing very, very quickly. So these are two things that help our users work much more efficiently when leveraging Kubernetes. The hotbar, and it's the command palette. So this is actually one of my favorite

10:36 Feature Deep Dive: Built-in Prometheus Metrics

10:38 features within Lens, and it's, I call it the pre built in Prometheus. Lens automagically yeah. I used automagically. It's new word I'm using, David. So so Lens automagically, allows you to leverage a prebuilt in Prometheus directly into your cluster, meaning I can very easily see how my cluster is performing in the last hour from the CPU to the memory, the disk, and so forth. And I can also see the total nodes, the total capacity, the actual usage that I'm using, and that, again, is all in the last hour, and it's a very granular view. So we'll take a look at this,

11:19 in just a bit. The next thing, and this is actually probably my favorite feature within Lens because I find it to be the most useful, and this is the smart terminal. The smart terminal is is quite important, to to our users and myself. And the reason for this is within Lens, you may be working with many different clusters. Right? So I could be working with five, ten, 15, even 30 different clusters and more. And I need to be able to always match to the correct Kubernetes cluster endpoint. Right? That the API endpoint of that cluster. So

11:22 Feature Deep Dive: Smart Terminal (Context Switching)

11:56 when I switch from cluster to cluster, Lens automatically, matches to the correct cluster API endpoint, which is so important. Right? Because if I'm switching from cluster to cluster, I know that I'm connected to that correct Kubernetes endpoint when working with that cluster. So this is extremely useful when working with multiple Kubernetes clusters, maybe a production cluster, development cluster, or even different distros. You can be assured that you are always in the correct cluster endpoint, right, that you're always matching to that correct cluster API version, which is extremely important. Another thing I wanna mention is that Lens always

12:36 automatically connects to the correct kubectl and helm sticking to that correct version, within the terminal itself, which is a fantastic feature as well. And we'll take a look at these things in the demo. So the next one, another one of my favorite features probably, maybe third three or four down the list, when it comes to my favorite, but, this is being able to deploy Helm charts very easily. So Lens has the ability to view thousands of publicly available made Helm charts, and you can manage these directly in your cluster. Meaning, I can deploy a Helm chart

12:52 Feature Deep Dive: Deploying Helm Charts

13:15 directly to my cluster in a matter of seconds, maybe yeah. Or in in the matter of seconds with one or two different clicks. So this is extremely useful, when viewing different Helm charts or trying to deploy them directly onto your cluster, and we will actually be doing that today as well. We'll take a look at some Helm charts, the Helm charts that are available. We'll, we'll install a Helm chart directly to our cluster. And, depending on the Helm chart itself, we may even port forward into the application. Extensions. So this is my second favorite feature,

13:45 Feature Deep Dive: Extensions & Plugin Ecosystem

13:49 and there's a couple reasons why. So extensions are, plugins built directly on top of Lens. And the reason why this is so valuable is, let's say, for example, that, I am a startup within the cloud native ecosystem, and I have built a product tool or service that is able to tell me vulnerabilities within a Kubernetes cluster. So that startup organization and so forth can build a plug in on top of Lens where they can leverage our users, or our users can leverage that technology to be able to very easily understand the vulnerabilities within that cluster itself.

14:31 Right? So it's twofold. One, our users get to leverage new technologies, and two, our partners and the community and the the ecosystem can leverage our users to get up and running very quickly if their product service open source technology is brand new. Right? So currently, we have over a hundred different extensions built on top of Lens. Many of these I do wanna mention are not publicly available, but we do have 10 or 15 different publicly available extensions made for the community. Some are built by Team Lens, and others are built by awesome, partner technologies and companies like Aqua Security,

15:09 Kubernetes, QCost, and so forth. So we'll take a look at some of these extensions as well towards the end of the hands on demo. And lastly, spaces. I touched on this just slightly when we were taking a look at the unified catalog, and spaces should be thought of as a centralized cloud based offering on top of Lens. Really, what it allows our users to do is build collaborative spaces where you can add specific Kubernetes clusters to that space, and then you can invite a teammate member or a colleague to that space, and they will be able

15:21 Feature Deep Dive: Lens Spaces (Secure Collaboration)

15:50 to have specific, access to whatever's within that space. Currently, it only works for, excuse me, Kubernetes clusters, but we do have some exciting different things we will be releasing, in the road map and in the future. So, that's important to keep in mind. But long story short, Lens Spaces allows Kubernetes cluster admins to share access to their Kubernetes cluster securely. Well, excellent. We took a look at many different features already from the unified catalog, the hotbar, the command palette, the pre built in Prometheus, deploying helm charts, extensions, and of course, Lens spaces. From here, I think we're actually going to

16:17 Summary of Features & Transition to Live Demo

16:34 transition directly into the demo itself, where we'll take a look at Lens, how to get started, some of the cool features in action. And then if we have time towards the end, we actually will share a Kubernetes cluster with David today, and it should be an exciting session. So once again, I wanna thank you, David, for having me and the audience with us today. I'm looking forward to this to this demo, and, hopefully, nothing breaks, you know, in in live sessions that can happen. But I have a feeling I have a feeling it won't happen to us today. So without further ado,

17:10 let's jump directly into the hands on demo where we'll be taking a look at Lens, the Kubernetes IDE. I don't wanna worry you, Edward, but, I mean, I just look at clusters and they break. I'm just I'm just saying. Yes. Yes. And and they do break and they do break, and let's hope nothing breaks now. I've I've been taking a look at some of my clusters. So, everyone, this is Lens. Whoops. This is Lens here. And, David, you still can see my screen. Correct? We can. Yeah. Excellent. So this is Lens. When you're first brought

17:32 Live Demo: Introduction to the Lens UI & Catalog

17:43 into Lens, you're actually brought into that catalog screen that that we talked about about that cloud native directory where you can bring different tools, clusters, web links, spaces to to be able to very easily filter and manage all your different cloud native resources. Currently, there's only a couple of things supported, and I do wanna mention that the catalog was released, back in June of this year. But we do plan on releasing many other resources that can fit within the catalog, like specific automations and tools, that our users can leverage. Right now, we have our spaces.

18:20 And, again, that's that centralized cloud based offering that allows us to share access to Kubernetes cluster securely. We have our web links within our within our catalog as well. Anything can be added here. So one of the things I like to do since I'm I'm not the most advanced Kubernetes user, I'm I'm not a novice either, but, I like to have, like, a Qt CTL cheat sheet. So, you guys can see that here. And just since we're talking about it real quick, if I click this icon here in the hot bar, I'm immediately brought up to this Kubernetes

18:51 cheat sheet, right, which is which is quite powerful. And this one's built by Mirantis, but there's many others that I leverage as well, within the ecosystem. And there's some fantastic ones built by many different companies and developers and so forth. So, I like to utilize a cheat sheet depending on the activity that I'm doing. And again, those are the web links. Then we have our clusters within our catalog as well. All of these different clusters, and we can see within the source column, we can see that some of these clusters are local, and some are attached to Lendspaces.

19:26 We'll talk about the clusters that are attached to Lendspaces a little bit more in just a moment. From here, what I really want to do is actually begin taking a look at the true functionality behind Lens. The catalog is fantastic when trying to access different resources, but the true power behind Lens is the full situational awareness that you get when working with Kubernetes clusters. So on the left hand side, we can see my hotbar here. I have a k zeros cluster. We don't see any Prometheus here as of right now, and the reason for this is

19:35 Live Demo: Multi-cluster Management & Prometheus Metrics

20:00 I have not checked the box to have the prebuilt in Prometheus launch on this cluster, but we we will do this. Then I have my mini cube cluster, right, where that's when you can actually see the prebuilt in Prometheus. We can see how it's performing in the last hour from the CPU to the memory, the total capacity, the number of pods. And here at the bottom of this overview screen, we can always see real time events that are pushed to us as a user. Right? So we can see if there's any, problems, if we need to debug an object

20:31 and so forth right here in this spot. Then we also have our GKE cluster. Again, it's missing the Prometheus configuration, which is absolutely fine. We will actually install it and push it directly onto our cluster in just a moment. And then here, I do wanna mention that this is a demo cluster built by some of our, team members here at MERANTIS, and this cluster is shared with me. So this is not my cluster. I did not add it to Lens itself. This is just a cluster that's shared with me through Lens Spaces, which is quite, quite

21:06 cool. That being said, let's actually take a look at how you can add a cluster to Lens. So if you navigate to your catalog, click clusters, there will be a plus icon here. In this plus icon, there's two ways to add a cluster. Only really one way for the user to do it, but Lens actually automatically searches for a QConfig file on your operating system, and it will add that cluster directly to Lens without you having to do anything once you hit that plus icon, of course. Or you can copy the q config file directly into this,

21:41 let's call it a terminal, and you can add the clusters. So those are the two ways to add clusters directly to Lens. Going back to my k zeros cluster, let's actually jump into the settings here. Right clicking on the hotbar icon will bring us to our settings, and we have several different, functions that we can perform. So the first thing is we can always give it a name, which for this demonstration, I'm just calling it what it is, which is a k zero s cluster. And we can give it an icon. And the reason why this is awesome, and we

22:11 touched on this a little bit, in the slide deck, but it's that efficiency aspect. Right? Being able to navigate from cluster to cluster very easily just by an icon. So as we can see, we can see this is a k zero. We can see this is the Mini Cube logo, and here's a GKD cluster as well. Going back to our settings, we are actually gonna drop down to the Lens metrics, and we're gonna add the metrics directly to our cluster by doggling these doggles here. Click apply, and this is where something may break. Let's hope not, but, I'm I'm sure it's gonna

22:45 be fine. We have multiple different Kubernetes clusters here already. So, even if something did happen, which I highly doubt it will, but even if something did, we can always switch to a different cluster. Right? And then take a look at, all of the features from that cluster itself. So let's just close this here. Go to nodes. Let's see if it begins to actually add the pre built in Prometheus slowly but surely. It may take a while to do this since it's actually installing it. So it did not wanna do it. Let's see what's going on here.

23:22 Maybe if we come back to it in just a second. Let's see. We'll go to settings one more time. Let's just take a look at what's happening. We have auto detect. Yes. And then Lensmetrics. They're toggled. Okay. Generally, I think this takes a couple minutes to do, which is absolutely fine. But from here, we'll just jump into our Minikube cluster. Now within our Minikube cluster, we do have that prebuilt in Prometheus directly pushed to our cluster. And as mentioned, we can see how it's performing in the last hour. On the bottom, this plus icon, you can

23:56 Live Demo: Smart Terminal in Action

23:58 do two very cool functions. You can open up a terminal session, which is that smart terminal that we mentioned already, where it automagically matches to the correct cluster endpoint. So if I write kubectl git nodes, you can see the version. Right? Kubectl version. You can see the git version. And if I switch to my k zeros cluster, and there's the Prometheus as we can see. So it just took a couple minutes to do. Right? If we switch to my k zeros cluster, we can see it's connecting to the correct endpoint, and we can see it's a different Git

24:35 version. Right? So whenever we're navigating to a new cluster, it's automatically doing this on its own. So we are reducing user error here when switching from cluster to cluster, and you can see it's different for our GKD cluster as well. So that's the smart terminal, and it's extremely important to note that Lens and we'll be taking a look at this in a moment. But Lens is always leveraging your role based access control from your QConfig file. If you do not have the correct permissions from your QConfig file, those particular functions and things that you may want to

25:10 do to your cluster that you will be unable to do. So let's move on from here. We have our nodes. Again, we can view our nodes, how they're performing in the last hour from the CPU to the memory, the disk, the pods, and so forth, and we get all of the details associated to this particular object. Right? So we have our labels. We have the operating system. We have the OS image. We have the kernel version. We have the container runtime, the cubelet version, and, of course, the capacity and all of the pods that are associated

25:14 Live Demo: Browsing Cluster Resources (Nodes, Pods, Details)

25:41 to this node as well. Right, which is extremely useful for one debugging or just trying to navigate through your cluster very easily without having to write any KubeCTL. Right? So I know many developers that like to take this route or even operators, SREs that like to take this route because it's going to save them a lot of time instead of always having to write, within the CLI different command lines and so forth. So if I chose to do so, I can actually click into one of these pods. And, again, we're given a granular view of

26:12 how that particular pod is performing in the last hour with all of the details necessary again. From here, I do wanna highlight some of the functions that you can perform within Lens as well, again, based off of your RBAC. Right? We're always leveraging your RBAC for your Kubernetes cluster. So we can shell into the node. We can the node. We can drain the node. And, of course, we can edit this resource, right, if we choose to do so hitting that pencil icon. We can begin configuring, debugging, and making changes here if we choose to do so,

26:45 which is quite, quite awesome. So we'll close this again. And, of course, we can delete it, which is something I don't want to do for for for all honestly. But that that is something we can do as well. From here, we'll transition to our workloads, and we get an overview screen here as well. You can see your pods, your deployments, your staple sets, and so forth. I wanna mention that these green, color code that we see is good. So, typically, if something was wrong with our cluster or within one of these objects, whether it's a pod, a deployment, and so forth, we'll

27:00 Live Demo: Workloads Overview & Resource Map Extension

27:19 actually have different color codes throughout this sphere. So we can have, maybe running with, say, 12, and then it would say warning message one, for example, on the pods. Currently, we do not have any of those, which is fantastic. I know this cluster is performing fun. And on the bottom here, and this is actually one of my favorite extensions ever built, and it's built by one of our developers here at, Orion, this is Team Lens specifically. And this is something we'll take a look at in just a bit as well, when we get to the extensions

27:50 side. But this is a beautiful extension that allows us to see how all of our Kubernetes resources and objects are related to one another. Right? So zooming in, we can see our Prometheus, everything that it's associated with, and then, of course, we can get details into this config map, the namespace, and so forth. And then clicking on it gives us that granular view again, of that object deployment pod, whatever it may be. Right? Yeah. That resource topology map is pretty sweet. I like that. It's it's awesome. Right? And you know what's so cool about it

28:25 too is when you're working with, a massive cluster. Right? I mean, this is this is a smaller cluster, but when you're working with a massive cluster and being able to see how how everything's, connected and, and with all the objects and resources, it's absolutely awesome. So, yeah, I love this one as well. It's actually my favorite currently made, available extension, and I I leverage it all the time. So from here, we'll click into pods. There's several ways to do so. You can do it from the overview screen or you can click pods here, and it immediately gives us

28:56 this beautiful, user interface where we can filter very quickly. So again, if this is a massive cluster with, let's say, 50 to a hundred different pods, for example, we can very easily navigate, based off of the filters here. I do wanna mention these filters are very similar to, like, Excel, for example, or Google Sheets, where if you have a filter going, so if I'm gonna filter by default namespaces, this will actually follow us everywhere throughout Lens. So it's very important to notice and know this is happening. When I first was using Lens, I I swear to you guys,

29:34 I had it filtered for one of these different namespaces, and I thought I was going in going in insane searching for other deployments and pods and so forth because it was filtered down by the namespace. So I do wanna mention that, you do need to uncheck the filter as you navigate through Lens. It's quite important to mention. Again, you can also search for specific pods here. You can view the status and so forth. And the reason why, again, this is so valuable is if you have a massive cluster, you have to perform various different command lines

30:07 to view all of your objects within your cluster. So I just ran a quick command line, and now we can see, all of the different objects within our cluster. Right? Very, very easily when they were created, when they're running. But then, again, if you wanna view a specific object, you would have to run another command line to access that that that object as well. Right? Compared to with Lens, I can just click directly into this controller. I can view the metrics immediately of this pod, see how it's performing, again, from CPU, memory, network, etcetera. And then, again, I have

30:45 very various different functions that I can perform as well. Like, I can show them to the pod. I can view the logs, which is a fantastic resource. You can search through the logs. You can actually download the logs as well. You can share them with a colleague, for example, and so forth. Right? And again, you can edit that resource directly within Lens. Right? And that's what makes it that IDE is being able to to edit these resources. One thing I do wanna showcase before moving on is, the ability to create a resource directly into our cluster here. So when I click this

31:16 Live Demo: Creating and Scaling Deployments via UI

31:23 icon, we actually have some cool templates that you can leverage right off the bat. So, we can do a deployment. This will deploy an NGINX deployment directly into Lens as you guys can see, and I can create it and close it, and it immediately deploys this resource directly into our deployments. I've deployed this already, so that's why you can see the date is four days ago. And the neat thing about Lens is we really do leverage Kubernetes to to scale our different workloads and our deployments. Right? So I'm using the user interface here to actually scale this deployment up, so

31:58 I can scale it up to, like, let's say, 30. And if I jump to my pods, we begin creating all of these different, containers, right, all in real time. And, of course, this is Kubernetes doing this. Right? But we're just using the user interface without having to write any command line to scale this up, which I think is, quite quite valuable. So that's a very neat feature as well. And if I jump back to my deployments, I'll grab this NGINX. It's still processing, and here's that resource map that we can see that's going crazy right now.

32:34 But these are all those deployments, and they're the same deployment. So four, very, very cool. And, again, we see all of the details associated to this deployment. I'm gonna scale this back down. My machine is screaming at me right now. So we'll scale it back down. And if we scroll down, we begin terminating these containers, right, all in real time. Can I ask a question? Absolutely. So, I mean, this is really cool. Right? And been able to navigate through pods, deployment, Steven sets, people sets, all of that. Like, that's probably 80% of what I need to do. But what

33:01 Q&A: Custom Resource Support

33:13 about custom resources? Does Lens understand custom resources? Now let me center out with those with the same kind of nice visual UI? Absolutely. Yes. So we do have custom resources here. I don't have any added to my cluster, but you absolutely can bring in, like, for example, like, Istio or something along the lines of that directly to your cluster. So I don't have any on this cluster, but, yes, to answer your question, you can. K. We also have a question from the chat if you want that just now, or do you wanna wait? Sure. What is it? Russell

33:40 Q&A / Live Demo: Log Filtering

33:45 is asking, what filtering does a log view have? Can I use a regex to search? One more time. I'm sorry. I missed that, David. Russell wants to know from the log view on the pause, do we have the ability to filter those logs, and can I use regular expressions to filter that if needed? I believe so. Yes. I I do believe so. Let's take a look here. Maybe wrong, but I believe you can, actually. I think maybe the search at the top right. Yep. There it is. Yep. So if you just type tools, does that

34:23 okay. So it's like a highlight kind of search. Got it. Okay. Yeah. That makes sense. Awesome. Let's close this. And, so as you guys saw, we just deployed a resource directly into, our cluster as well, which was the NGINX deployment. We scaled that up leveraging leveraging Lens. So couple of things we've taken a look at already. Right? That multi cluster management tool. Right? Switching from cluster to cluster while always maintaining the correct Kubernetes endpoint, extremely important when working with many different clusters. We took a look at the pre built in Prometheus that allows us to understand how

35:00 our cluster's performing in the last hour from the CPU to the memory, the nodes, the pods, the capacity. And here, we have a we have a warning message as I talked about earlier. So if I open this up, it's going to give us details on this particular object, excuse me, which is a pod. Scrolling down, we can see the events and the more warning message here. Right? So this is gonna help us debug, troubleshoot, and so forth, within this particular object. Then we can, of course, view the logs and go from there. We also took a look at accessing

35:37 Live Demo: Browsing and Installing Helm Charts (Debugging Unbound PVC)

35:39 various different objects, one object to the other. We deployed a resource. We looked at the Prometheus. And from here, we're gonna transition into actually taking a look at the helm charts, the extensions, and then we will also create a new space, add a cluster to that space, share that space with David, and he'll be able to see that cluster as well. So from here, to be able to access your, Helm charts or down in this app section, you click charts, and then it'll immediately start bringing up all of the charts and the repos it's associated to. So I I

36:19 do wanna mention that, my current Lens desktop application, the way it's set up is I'm only going after certain repos as you guys can see here. And to do to change this, I believe you go to preferences. Let's see. Yes. And then here within this Helm chart section, you can add a custom Helm repo, or you can add, you know, from the thousands of repos that are publicly made available here. Right? I only use certain ones. So I use Morentis. I use Bitnami. I use Stable, and that's really it. This Cloudflare one, I don't even

36:56 think I use. So I can remove that, and then we can navigate back to our applications or our Helm charts, and we can search for particular helm charts as well. Right? So if I wanna deploy a WordPress helm chart, you click here. It's immediately going to give me all details associated to this chart itself. Right? Who's maintaining it, where it lives, keywords it's associated with, and, of course, how to get started with this home chart. If you even chose to do this, on your own, right, without deploying it through Lens, like, you can do it to the

37:28 terminal or command line and so forth. Scrolling back up, we're gonna install the sound chart. Let's actually close this pod stuff out. And this usually takes a couple minutes as well just as we did with the Prometheus that we saw on the k zeros cluster. Some details. You can make some changes here if you chose to do so. We'll click install. And it's been installed to our cluster. So several ways to access it, you can view the release here. And we can see all of the resources that were created for this Helm chart, the service accounts, the secrets, the config map, and

38:23 so forth. Right? So so that's very awesome to see. Another thing I wanna point out is actually the ability to, port forward directly into this application. So this should work fine, I imagine. Just a second. So if I chose to put forward into it, It's taking longer than usual. Yeah. I was wondering if that that delay was normal or if it was just having a wee spending problem to itself there. Yeah. It's it's not normal, actually. I wonder if my computer is just going crazy. Still to cover them from those 30 pods you spun up, I think. Yeah. Exactly.

39:17 The the mini q cluster, it is it doesn't like it. So let's give it one more try. Let's see if we can get into this port. Come on. Def the longest it's taken. That's fine. Let's actually this won't work. I doubt it. Yeah. But, unfortunately, it's not working here, everybody. Part of the live demo. Right? But, you can port forward directly into the application also on BLNs. What you would do is you go to services. That's why. I don't think it's got any endpoint yet. Yeah. Exactly. And so forth. So, anyways, that is port forwarding, and that is in

40:01 installing a Helm chart directly to our to our app to our cluster. Are the pods running yet? Let's take a look. So we have some problems. Unbound immediate persistent volume claims. Yeah. Yeah. Yeah. Yeah. So so we're having some problems here as you guys can see, and then we get that message that's, that's directly built into our into into Lens as well. Scrolling scrolling down, we can see a little bit more about it. Zero to one nodes are available. One pod has unbound immediate volume claims. So, again, if you chose to troubleshoot this, you have the ability to do so,

40:37 relatively quickly, and I think this is another reason why, we weren't able to pull forward. But that being said, let's not troubleshoot this right now. There it goes. But it it doesn't work because as David mentioned, there's no endpoint currently. You should be able to pull forward to that NGINX one, though, if you wanna do that instead. Let's give that a shot. Yeah. Let's go to deployments. But, actually, we'll go to services. Whoops. Where did you go? Oh, it's just part okay. It's just a deployment. There's no service for it. Yeah. That's what it's exactly.

41:13 It's still trying to open that for after I clicked all of those things. That's funny. Excellent. So we talked a little bit about home charts, but now let's take a look at our oh, we had a crash, guys. That'll be the last time you spin up 30 pods on your own machine. Yeah. Yeah. Yeah. Exactly. And in a in a live demo as well. So we're we're gonna get away from this mini cube cluster for now. We'll go back to my case zeros cluster and stay away from that. So now let's talk about extensions. And, currently, I have one extension added to

41:17 Live Demo: Exploring Extensions (Space Invaders, Resource Map)

41:45 this Kubernetes cluster, which is the resource map. To add extensions, very simple. You click Lens on the top and left side, click extensions, and you would install the extensions that are available to publicly available, or you can bring your own as well. So here are some extensions that are publicly available. We have Moreintas container cloud extension, which, allows you to connect, your MCC infra, and your Morantis Kubernetes engine cluster directly to Lens without actually having to add that QConfig file or have Lens search for it on your operating system. You have the starboard extension by Aqua Security.

42:26 This is an amazing extension that shows you vulnerabilities within your cluster as, within your cluster, and you have several different, fun ones as well. One of the funnest ones, but I haven't used in a long time. Yeah. I said funnest, but, it's space invaders. You can actually kill pods through this game. I don't know if it's been updated in a while, so it may not work. But let's actually, grab it and download it and see if, we can spin this up in our cluster. Again, I haven't used this in a while, and I know we don't really maintain this

43:01 one. It was more of an experiment. So going here, we can search for it. Look for our downloads. Let's just grab the name Lens app. Okay. No memory. There it is. Space Invaders. And then it'll begin installing to our desktop application. You can see it was successfully installed, and we get a status that it's incompatible. So it has not been updated in quite some time. So I'm gonna uninstall this, but we'll take a look at that resource map that is already installed, directly to our desktop application, which, is something we took a look at earlier.

43:47 So I'll just touch on this just one more time here, since we talked about it already. But here's our Kubernetes resource manifest, which will show us how all of our objects and resources, are connected to one another. And, of course, you can get the details. You could hover over them and view them. And then, again, you can click directly into them, right, and get that much more granular view of that particular resource. So the stateful set Prometheus, the CPU, all the way to the file system. Right? And, of course, we can jump into this resource and make some configuration changes as

44:21 well. So many things we've covered already, and the last thing I really wanna try to get into this demo is Lenspaces, which is our newest, feature and release brought to Lens, and it's actually a very, very cool release. Again, it's a centralized cloud based offering that allows cluster admins the ability to create these secure spaces that allows you to share access to a Kubernetes cluster. So you're not giving anybody access to your KubeConfig. You're actually just giving them access to the cluster. And, initially, it's just like a read only. Right? And then you would actually have to

44:31 Live Demo: Introduction to Lens Spaces & Creating a Space

44:59 change the role bindings and and the roles within that cluster and that QConfig file to give them further access. So for example, if I wanted to give developers, access to a Kubernetes cluster, maybe they want a few logs of a microservice or something along these lines, they can do so once you make a little bit of changes to the kube config. So from here, what I'm going to do is I'm going to create a space. I'll click this plus icon. We're gonna call it Rawkode. Good name. Not create space. Ah, I know why. It's because I have too many spaces.

45:20 Sharing Cluster Access Through Spaces

45:37 Let's go to my profile, spaces. We can leave that one, and we'll leave this one as well. K. Now let's create a new space. Could not create space. Is it because my username is Rawkode? No. No. I I don't think so. Let's try. I think it has to do with, how many spaces and clusters I've shared. Let's try IoT. Wow. Maybe it does have something to do with your with your username. I'm gonna have to take that back to the team and and see exactly what happened here, because that is a little bit alarming. Anyways,

46:34 Live Demo: Sharing a Cluster via Lens Spaces (Installing ClusterConnect)

46:34 now that we've created our space, what we can do is we can actually add our cluster directly to this space. So if I take this Minikube cluster, I can share it, and we can share it to this IoT space. Here, what we need to do is we actually need to install cluster connect directly to our cluster. This creates an end to end encrypted tunneling between, the cluster and the API itself. So clicking here, install cluster and share. So we've added that to our cluster. Now what I actually have to do is I need to invite David to this space,

47:18 and then he'll be able to see the space and have some, access to that Kubernetes cluster. Again, it's read only initially. You would have to alter the role binding, and the R back to be able to actually give him further access to that to that cluster itself. It's quite secure. So Could we have a a question on that in the chat if you're happy to Sure. Sure. So Russell asking, is the authentication mechanism using RBAC or something else entirely? So I think what Russell is asking there is when we install ClusterConnect, is it creating an RBAC, a role and a service account?

47:55 It is. Okay. It is. Yes. It absolutely is. So now we'll click. This is you, correct, David? I believe it is. Well, I'll ask you. That is me. That's me. And we'll click share cluster. So I've sent you the invite, and what I will do now is I will actually stop sharing, and if you can begin sharing, Lens and your screen, and we can go from there. Done. So jumping back. Stop sharing. You know, I almost clicked hang up. That was a close Wouldn't be the first time. I can see your screen. You said it wouldn't be the first time? Yeah.

48:11 Live Demo: Accepting Space Invite & Accessing Shared Cluster

48:34 I've been hung up on before and not intentionally. Of course. Of course. But I That's that's funny. So from here, what you'll have to do actually is you'll navigate to the Rawk on the bottom right. You're using it, and you'll click my profile. And here, you'll click spaces, and then you should see an invitation to that space. Once you accept that invitation, you can navigate back to your catalog where that space now lives in that, like, directory that we mentioned, and just clicking that x icon at the top right will allow you to do so.

49:07 It created a default space of my username. I think that Yeah. That explains why That is what happened. That is what happened. Yes. Yes. Yes. That is what happened. And then catalog exactly. And there you can see those clusters. Right? The Lenspace cluster from here. And it looks like it added, your own clusters already, to to Lens. At at least that's what it looks like. So clicking that, and then you can click click to open on that big m I button on the left. Oh, right. Yep. And then it's gonna begin opening that cluster itself directly to your Lens desktop application.

49:51 Remember guys, it's only read access initially, so he will not be able to perform specific functions. That's why he doesn't see the Prometheus. Let's see if you can even take a look at the nodes. I'm curious. It does show you. But if you tried to do any admin functions here, like drain the node or shell into the pod or something along these lines You feeling brave? Try it. Dreads. Well, excellent. So, as you guys can see, we shared a space with David and, added that cluster to that space, and now he had access to that cluster itself,

50:42 which is so, so cool. Yeah. He can view some of the resources, some of the pods, some of the objects here, but he won't be able to perform anything that can scare us. See if you can view the logs, David. On the top right. Yeah. There it is. Yeah. One over. Yep. Nope. I don't think so. Okay. We don't have any, I guess. Or or that could be the case. Yeah. What are we looking at? WordPress. It looks like your WordPress is finally happy. Now? Think it's didn't wanna be. Yeah. Hold on. Let's see. Let's

51:30 see. I'm curious. It's the spinning wheel of death. When that happens on my MacBook, I wanna cry sometimes. Yeah. Maybe I don't have permissions to set up a port forward. Exactly. Exactly. I am actually releasing a blog where I have a guide on how to give new permissions directly to a user that wants it for for their specific space. Oh, you can use the logs. Yes. NGINX doesn't have any logs, but the WordPress app definitely does seem to have some. So there we go. That's cool. So this is your local cluster on your own machine that you're sharing to me via

52:11 Lenspaces. Exactly. Yeah. Exactly. And, again, that's done by cluster connect, which is an end to end encryption that creates that tunneling that that we talked about already. What kind of technology is the tunnel using? Something like WireGuard? That's actually an excellent question, the FireFlash. I don't have that answer for you right now, and I apologize for that. I do know it's a Damian set, but I do not know exactly what the technology is itself. But you can access the open source technology, which is called BoardD. It's created by Team Lens, and you can actually spin this up on your own. So it

52:51 doesn't have to be used for Lenspaces. So I know that doesn't answer your question, and I apologize for that, but you can access four d and just grab it and be able to actually create this similar experience without Lenspaces. I tried to edit your surface, but I got permission to find. Dang. Good. Good. I like I like that. Lens spaces is pretty nice. That was well, it was seamless. Just opening up Yeah. It's joining it and then poking around like a very curious rabbit, but very nice. Yeah. Yeah. Yeah. And this is something that I think,

53:28 many of us may have troubles with, whether you're a cluster admin or a developer needing access to to a QConfig file. Because we're never giving you access to the QConfig file. Right? You're getting access to that space. And based off of the RBAC and the role bindings, you can give them further access to that cluster, which is super, super useful. And, as mentioned, I am releasing a blog, either today or tomorrow. It'll be on my Medium channel and on Team Lens where I actually have a guide on how to give the correct role bindings, let's say, for a developer that wants to

54:00 access, a Kubelet namespace or something along these lines or a default namespace or whatever the namespace may be, and a specific team. So one thing we didn't take a look at here is I just added you as a member, but you can actually create a team within that space, and then that team will be given specific permissions based again off that role binding that we would do, to the KubeConfig file itself. So you're just a member right now, but if I created a team for developers and then I added that particular command line and that snippet, that code itself,

54:34 I can easily give you specific access to namespaces and so forth, whatever functions you're trying to perform to that cluster. So we're seeing many users, leveraging this for, let's say, for example, viewing logs of microservices or applications and so forth so forth. Right? So extremely useful, and I think we all know how challenging sharing access to a Kubernetes cluster may be. Viral, VPNs, air gap tunneling, all these different parameters that we need to jump through in the hoop hoop. So this is why we develop Length Spaces because we're hoping that it actually helps our users and the cloud native ecosystem.

55:14 Nice. Very, very cool. I like this a lot. So well, it looks like we got a comment. Maybe it's from someone on your team, Ty Martin? I've never met Tai Martin. No. So but that's agent's model is an outbound connection to the Spaces service, which works as a secure proxy. That is correct. Yes. There we go. Thank you, Tai. Is there a favorite place to search for extensions? Absolutely, Daniel. So the best way to access extensions is actually what I showcased. So if you just go to the Lens application, go to that extensions, icon, it will link you directly to,

55:19 Final Q&A and Discussion (ClusterConnect Tech, Extensions Search, Cluster Compare)

55:50 all of the publicly made available extensions that Team Lens has vetted of being safe. This first line. We have another question by Russell. I'll take a look at this. Can Lens compare clusters? Example, a Teams test versus live clusters to highlight differences. No. I I do not believe we can do that. No. But that's actually really good feedback, and I'm going to take, note of this if you guys don't mind, because that's actually super interesting. Thanks for pointing that out, Russell. But, no, we can't do that as a right mark. That's first line of authors

56:26 highlight a lot of That's actually a super good idea. And and, Kai, I also wanna thank you for jumping in and answering that question for me. I really do appreciate that. Thank you. Sweet. Awesome. Well, thank you very much for taking time out of your day and and joining us and showing us all the features of Lens. I think we can all agree it's a pretty impressive tool. I think the extension thing is awesome, and I'd love to see what people come up with there. There must be so many random ideas bouncing around in people's heads, and I can't

56:41 Conclusion & Contact Information

57:00 wait to see them. So Yes. Agreed. Agreed. For example, cube cost has a great one, which will tell you how much you're spending on your Kubernetes clusters. Right? It'll it'll break it down for you and so forth. I mean, similar to what some of these public cloud offerings do for us. Right? But it's very, very cool. It's directly intertwined with with Lens, and there's many different extensions. So I agree with you. That's super awesome. One thing I did wanna do, the last thing, David, if you don't mind, is just share a screen with our contact information

57:30 where people can find us, if they have any questions for me, if they have questions for the team, if they wanna join the Slack channel, if they wanna receive a hoodie as well. So Yeah. Go for it. Awesome. So I'll share my screen one more time, everybody. I know we're at an hour now. And last thing, here's where you can find Lens. You can also download it from our website. There's my email at Morantis. Here's a Lens email. And join our Slack community, and feel free to ping me. Just ping me on Slack or ask questions on Slack. All of our

58:02 team members are there, and some of the really core developers and contributors to the open source project are there answering questions day after day. And if you're interested in a hoodie depending on where you are in the world, I'm more than happy to send send you guys some cool hoodies and swag. We we want everybody to feel extremely welcome to the community because, again, we could not be where we are today without the amazing cloud native ecosystem. So thank you all again. And, David, thank you. Alright. I will definitely drop those links into the show notes as well and the description.

58:31 Final Farewell

58:36 So I'll make it easy for everyone to click, get some information, and get the hoodie. Alright. Well, thank you again. Really cool product. Great seeing that start to finish. Everyone, go check it out. Let me know how you get on. Join the Discord, and I'll speak to you soon. Edward, thanks again. Have a great day. Okay? You too. Thank you. Bye bye.