(So you can skip ahead, if you want.)

0:00 Intro & Setup
2:55 Generate LLM Script
7:30 Commit & Push to GitLab
12:20 Create Service in Itential Platform
13:10 Build & Test Workflow
18:45 Self-Service & API Exposure
20:25 Wrap-Up

Joksan Flores • 00:01

Hi everybody, my name is Jackson Flores. I am a principal solutions engineer at Attentional and today I’m going to show you how do we actually integrate Vibe coding into our day-to-day for network automation activities and also more importantly, how do I expose those services securely as self-service to my user. So I got a little picture that I draw that I drew little stick figures here in DrawIO to kind of explain the point. So this is me here. Hey, hello. I’m a professional Vibe coder and I’m going to be building some code using Cloth today. I’m going to use some Anthropic models, Sonnet 4.

Joksan Flores • 00:40

Specifically in this case, you could actually use your preferred client. So GitHub Copilot. I use Klein. But you could use that or use clot code or codex or Gemini CLI, any any one of those to build your actual script. And when things start getting interesting, is what we’re going to do is we’re actually going to take that script and commit it to our GitLab repo. Once we commit that, that’s going to launch a pipeline in the development branch. Within the development branch, that pipeline will say, well, we’ll actually take the script from the repo and push it into our dev automation gateway.

Joksan Flores • 01:13

And once that is done into our IAG5 environment, once that is done, the IAG5 can actually pull the script from the repo, build the requirements based on the requirements that text that gets specified or pryproject.tomo. And expose those services to the platform as a service. So we’ll actually go and create a workflow, expose that as a service very quickly. And we’re going to do Python today, but we can actually do this with Ansible or OpenTOEFL assets and so forth. So let’s crack into it. Okay, so here I have my VS Code. I have cracked open little terminal to do some of the things that I need to do there to commit files to the repo and so forth.

Joksan Flores • 01:50

And I also have my directory open. So this will be my directory for my Python assets. I already have a couple assets here, and there’s a GitLab CI will holds the pipeline. What we’re going to do is we’re going to create a new folder and we’re going to call it Amico iOS parse interface. And I’m going to copy that into my clipboard because I’m going to use that as an instruction for the LLM. And then we got it there, and that’s all well and good. And then, so we’re going to have to do two things.

Joksan Flores • 02:19

We’re going to have to create the script inside of this folder, a requirements.txt or a pyproject.tomo. We’re going to keep it simple today. And then also, we’re going to have to have the LLM create a services file. So we have a service template here that tells the LLM what to do with all of these values. This is very specific to the gateway, but we can actually see how the LLM can help us create some of these things very quickly based on the template that we’re providing so that we can just, you know, expose the script very, very, very quickly to the platform as a service. So let’s go ahead and close that and let’s get into Vycoding. Okay, so let’s start a new one.

Joksan Flores • 02:57

And what we’re going to do is we’re going to tell, hey, let’s create a Python script using NetMiko, Nemiko to parse interfaces on an iOS device. Put it in this directory. Let’s do parse interfaces, operational status, fashional status, counters, etc. etc. on an iOS device and then put this directory in that folder. Create a requirements that text in the same text in the same folder. This script should use part parse to collect the device name or IP address and use itential itential for username password.

Joksan Flores • 04:07

Yeah, so we’re gonna use some some generic username password for testing today Obviously, you know later on we we would secure that Let’s see we got everything so it’s gonna be pulling the interfaces pulling the interface status and so forth. Let’s use Unintended Mako Using let’s see using the show IP interface command Okay, I think we got enough instructions in there. We’ll go and actually do some supervision over the process, but I think this is good enough. Oh, also, so we told it a creator requirements.txt.file in the same folder, script should use our parse, and also we’re gonna have it create a service file based in the.gateway slash services sys directory based on the provided example. Okay, let’s go. So, this would be at least a scaffolding for what I wanted to do. Obviously, I can take a script that I already have and I don’t have to go through this process of having it regenerated.

Joksan Flores • 05:19

I’m kind of just trying to illustrate the point on how you can, you know, vibe coding is all the rage nowadays. So, just trying to kind of show, hey, how you can actually get this, get something done very, very, very quickly if you prefer to use this kind of mechanism to talk to devices and expose it as a service using the Attention platform. So, let’s let it do its thing here. It seems like it’s actually doing a pretty extensive job. Yeah, so all that code would probably take me a while to build and you know, through some growing pains. So, it’s actually kind of cool to see how it gets done very, very quickly here. Okay, so now it’s going and creating a requirements.txt file for us, which is required, like I said before, for the gateway to know the dependencies that it needs.

Joksan Flores • 06:31

In this case, it’s pretty simple, just needs an emico library. That’s going to create me a service file, which is great. We’ll look at actually what I created in a second once it’s done. And we’ll look, we may have to make some adjustments to this. I kind of already see, you know, spot one thing. Okay, so now it’s going to create my little readme. This is kind of a thing that it does unless you tell it not to do it, which is that’s a good practice, right?

Joksan Flores • 07:29

It’s good to have a little documentation on it. We won’t be able to test the script here, but we’ll actually have to go and test it from the lab, which is okay. So we’re going to go and commit that to the repo and have that actually done. So if it tries to test it, I will stop it. I think it’s just going to go summarize now what it did. Okay, perfect. So the script is already created.

Joksan Flores • 07:51

It did a help command and it has one flag that it accepts. So it accepts IP address or a DNS name. And it also has some optional flags, which is fantastic. So we’re just not going to go ahead and do that. Let’s let it run that. Yeah, so you can see here inside of the directory, NetMiko iOS parse interface, it has the script, the readme, and the requirements.txt that it created. And that’s great.

Joksan Flores • 08:17

So we’re going to go ahead and close those. And then let’s go ahead into here and look at. Okay, so it actually, yep, it go ahead and created the parse interface file. And this is a service file that I need in order to get this from. This is what the pipeline uses to add the service into the gateway. So let’s go ahead and expect that file, which is the most important one here to get the script in. Working directory, it’s all this is fine.

Joksan Flores • 08:42

The repository, it’s creating it down here. We’re going to actually go ahead and delete these requirements of these runtime arguments. The gateway already assumes that there’s a requirements.txt file and it miko has some defaults so we don’t need those well let’s leave the environment variables there Let’s go ahead and keep the runtime. And it also built me a decorator, which is actually passes in the arguments for the script. So it lets you, it actually models the arguments for the script, which is kind of cool. So it’ll have, let’s see, device IP address.

Joksan Flores • 09:12

So it has a device name, which is a string, username, password, some output format, etc., etc. etc. Include raw output. I don’t know that I want all those. I’m actually going to go and keep it simple. So I’m actually going to go ahead and delete all those and say. Properties using well, you know, actually, we’re gonna we can we’re gonna leave them all.

Joksan Flores • 09:35

Okay, let’s go ahead and leave them all. So, we deleted the runtime requirements.text because the gateway already assumes that. Okay, so let’s go ahead and do that. So, let’s go ahead and commit this. Um, let me go ahead and make sure that I’m in the right branch. So, I’m in development. I’m gonna commit those.

Joksan Flores • 09:52

Uh, well, let’s do a get status first. What are we adding? Okay, so we’re adding the YAML file and then a micro script, right? So, yep, so we got four changes in there. Okay, let’s actually push it from here. So, let’s do addito iOS parse interface interface script, and that’s gonna go commit it into the development branch. So, we’re gonna go ahead and commit that and push.

Joksan Flores • 10:24

I know stage changes. Would you like to stage all? Yep, let’s do that. Okay, that let’s go ahead and push it. So, now we’re gonna go here and actually let’s go into my GitLab to actually see the progression of the pipeline. Okay, committed already Okay, let’s wait for this to load Okay, so let’s go into the Python directory so we see we committed it 33 seconds ago with a python project Okay, got committed. Let me look at the pipeline execution should loading here Okay, so let’s go into jobs because I do want to see the job pushing into development

Joksan Flores • 11:37

Just now, okay. Let’s see. So, we’re actually going to go ahead and inspect this. So, we can actually see the pipeline. There’s a lot of logs in here. The one important thing here is that it picked up the development environment, which is the one that we’re going to push to, and we’re going to do a put, you know, it was a push to the pipeline on the branch devil, and we’re going to push to the development IAG. And then, the other thing that we want to do is we actually want to go through here.

Joksan Flores • 12:03

Okay, perfect. So it actually added the service. So successfully added to it added that Namico iOS parse interface service that we just created. And let’s see if we go down here. Okay, perfect. We got it down here. It’s a Python script.

Joksan Flores • 12:18

We can see it as a service on the gateway. And we could actually go and inspect this in the gateway CLI. But what we’re going to do is we’re actually going to go to the itential platform directly. And now we should see that. Okay, so now that the service has been added via the pipeline, we’re going to go ahead and check it in the itential platform here. So let’s go ahead and let me go and refresh this page and go into this gateway, which is the one that we’re using for our dev. And we can see that the script was actually added here.

Joksan Flores • 12:45

So we got an amico iOS parse interface and we got all its attributes based on that decorator that got created. So what we’re going to do is we’re actually going to go ahead and put that into a simple workflow and expose it. So here I am in my canvas. I’m just going to go ahead and create, you know, this is just a basic scaffolding of a new workflow. It’s called MyScript Service. It’s just for testing and for showing this. So we’re going to add one single task into this workflow.

Joksan Flores • 13:13

I’m going to create it, connect it to the start and the end. And what we’re going to do is now, this is a task called run service. And we’re just going to go ahead and look for my script. Let’s do Python only. Well, Python only. Here we go. So we got our script there.

Joksan Flores • 13:37

For our device, we’re going to use my test device. Let me just expand this up a little bit more, close that there. We’re going to use my device, which is this is the IP that I use for it. Format, we’re just going to leave a default. Output, we’re just going to leave it default as well. We don’t need to save anything to file. One cool thing is to note here is that decorator that was created, it’s actually honored on the platform and it’s all dynamic, right?

Joksan Flores • 14:03

Once the service gets added into the gateway, it just shows up on the platform as the service inside of this task. So now my script is exposed to my workflow and I can wrap it with all sorts of things, right? I could do change management, I could do all sorts of other things. I can add service now tasks, you know, IPAM tasks, etc. So let’s go ahead and configure these tasks here. I’m going to do some static values for now. The password and username had default.

Joksan Flores • 14:27

So itential for the username, raw false for this attribute, and the username is itential as well, verbosity false. So let’s go ahead and do that and leave it all default. And we just added the device IP. And let’s go ahead and run it to test this thing. Alright, so let’s go ahead. Once the service has to be run the first time, it’ll actually, the gateway has to go and clone the repo, do a pip install, install the dependencies, and then run it. So this gets added all dynamically.

Joksan Flores • 14:54

Granted, you know, keep mentioning this a little bit, but this can be done for any, any services that you have. Okie dokie. So actually, yeah, it did it from the get-go. That’s pretty cool. So let’s go ahead and actually, we actually can see here. So run service, if you look at the standard out, you actually can see that the output was parsed and shown here as a string, obviously. So let’s go ahead and actually show this.

Joksan Flores • 15:20

So let’s go ahead and add a little bit more stuff to our workflow. So let’s do a view, a view task, right? So super simple. Added that one here. And also the one thing that we have to do is query that value out because the output is all return as a standard out. Where’s my gray task? Do.

Joksan Flores • 15:43

oh there we go okay so we’re gonna do that let’s just organize my workflow here so it doesn’t get too big let’s keep it super super super simple so we’re gonna query uh result that standard out which is uh what we saw there in that object this just basic json path if you look at this result object that std out so i’m gonna go ahead and do that in the query uh the object’s gonna be the gateway service result um and this is correctly configured i’m gonna save that and i’m also gonna say uh parse interfaces output um these are all mandatory so i’m gonna put some values there and then the body we’re gonna put the result of the query we don’t need no variables and we’re gonna say end job and uh nothing for failure so let’s go ahead and do that and let’s go ahead and run again So now I have my service here very quickly running. I can display some information for the user. So I took my script in very few minutes, I created a script, it’s by code, that script, exposed it, added into the gateway. And look at that output. So very cool. The output is obviously formatted as a JSON at the moment.

Joksan Flores • 16:58

I could format this as a string. I could make it into an HTML. But now I got all the information that I needed from my device, which is what I wanted to do. So the device is 101897. It’s got all the interface counters and all the stuff that I need, right? Set switching enabled, all the information that I wanted to extract. And if I wanted to do this again, if I wanted to modify my script, I just need to go back to my local file, modify my script.

Joksan Flores • 17:26

Commit it to the repo and it just gets added automatically, right? I can just pick up new versions of the script as I go along. The last thing that we need to do to put a ball on this is just going to expose this as a service. So, what we’re going to do is we’re going to change this device IP or host name attribute into a job variable. And what that will do is that now will let me pass it in as an object. So, what we’re going to do to kind of add a little bit more finesse to it and make it a little bit more pretty, we’re going to do, we’re going to add it into our self-service interface. So, we’re going to put it in operations manager.

Joksan Flores • 18:02

So, let’s do a JSON form. And we just need one field for in this case. So, we’re just going to go ahead and do that. And the variable was named device. So, we’re going to do device here. But we’re going to put here device IP/slash name. So, one label.

Joksan Flores • 18:18

This is going to make it so that our users don’t get confused. So, this is super simple for them. Obviously, you could have this be all the parameters. If I wanted to pass in custom interfaces, the credentials can be held in a secret vault. Obviously, that’s all part of the script logic, but there’s all sorts of possibilities of the things that we could do. So, let’s go ahead and do this here. And then 1890, let’s go to text.test.form very quickly, and it’ll pass device.

Joksan Flores • 18:45

Yep, that looks good. And let’s check my workflow to make sure that that’s what the workflow actually wants. And that’s the variable device. Perfect. So now we’re going to go into our operations manager and we’re going to go back and we’re going to create a new automation entry. And we’re going to call it parse interface service. Or let’s just be a little bit more elegant.

Joksan Flores • 19:09

Interface parsing service. Okay, perfect. So we created a new automation. We’re going to pick the workflow, which is my script service. And I could name this whatever. So my script service is there. We’re going to create a new form entry input.

Joksan Flores • 19:29

We’re going to pick it as a manual. And then we’re going to call, we’re going to find our form. And our form takes the IP address and it has that there. So I’m going to save that. And then also the other thing that I can do is we talked about this at the beginning, I can actually create an API trigger for this. So I’m going to go ahead and create a API endpoint for this service. And now I have what do we call interface.

Joksan Flores • 19:57

Parsing, yeah. So I can create an API route very quickly, and now my service is exposed via two mechanisms. I got a fat manual trigger for it that I can just launch it from here so my users can use this as a self-service operation, as a self-service tool. And then, also, if I needed to have it as an API endpoint, I have it as an API endpoint exposed as well. Same workflow. Let’s go ahead and test this out, make sure that it works. Pass it to our test device.

Joksan Flores • 20:26

101897 looks good. Let’s go ahead and run it. And I’m going to start auto-work. Okay, perfect. So our service work, we created it all entirely using bytecoding techniques. I went ahead to my VS Code, created the script from scratch using my prompting skills and using my LLM. And I was able to commit it to the repo.

Joksan Flores • 20:54

The pipeline executed, added the script to my gateway. That script gets exposed into the platform automatically and it shows up as a service. And now I can build a workflow around it. Obviously, I can do other things like if I wanted to put some other tasks around it. Like if I wanted to do service now, service now things, I have service now create CR workflow. So now if I needed to do a service now CR behind this before the workflow, before the script execution, I can go ahead and do that. I could take the script and attach it to a ticket.

Joksan Flores • 21:25

I could take that output and pass it into a Slack notification, etc. The possibilities are endless, but we can very, very, very quickly create a script, expose it to the platform, and have it have all the governance that it requires, right? Have all the SSL, the RBAC capabilities, use my OAuth account, have API triggers, all those kinds of things that we would need in order to operationalize my script. Okay, that’s all I have for this showcase, and hope you enjoy it. Thanks for tuning in.