DEV Community: Luca Sepe

I'm building a read-only context engine for Kubernetes and AI agents

Luca Sepe — Mon, 15 Jun 2026 08:03:09 +0000

Kubernetes gives us an incredibly powerful API.

It also gives us a familiar debugging ritual:

kubectl get pods
kubectl describe pod ...
kubectl get svc ...
kubectl get endpointslices ...
kubectl get deployment ...
kubectl get events ...
kubectl get application.argoproj.io ...

Then we mentally stitch the result together.

Which workload owns this Pod? Which Service routes to it? Are there ready endpoints? Is the namespace unhealthy because of one bad Deployment, a missing backend, warning Events, or something else?

Which facts should I paste into an incident, attach to a CI failure, or give to an AI assistant before asking it to reason?

I started building kctx because I wanted a small tool for that missing middle layer: not raw YAML, not a dashboard, not an auto-remediation system.

Just structured Kubernetes context.

The short version

kctx is a read-only Kubernetes context engine for humans, scripts, and AI agents.

It turns live Kubernetes API state into a compact model of:

entities: Pods, Services, workloads, Nodes, PVCs, ConfigMaps, Secrets, and supported CRDs
relations: ownership, selection, scheduling, service routing, and dependencies
signals: factual observations such as unhealthy Pods, missing endpoints, warning Events, failed readiness, or degraded workloads
graphs: dependency and ownership views around supported resources
dumps: deterministic namespace snapshots for automation, incident review, and agent grounding

The design goal is intentionally conservative:

read cluster state, normalize facts, avoid speculative root-cause claims.

That boundary matters.

I do not want kctx to be a tool that confidently invents explanations. I want it to provide the evidence layer that humans, automation, and AI agents can use before reasoning.

Why another Kubernetes tool?

Most Kubernetes tools are optimized for one of a few jobs:

kubectl exposes the raw API very well
dashboards make current state visible
monitoring systems track metrics and alerts over time
logging systems answer "what happened in the process?"
GitOps tools understand desired state and sync status

Those are all useful. I use them too.

But during debugging, there is still a recurring gap between "I can query every object" and "I have a compact operational picture of what is connected to what."

For example, when looking at a Service, I often care less about the complete YAML and more about questions like:

Which EndpointSlices back this Service?
Which endpoints are ready?
Which Pods do those endpoints point to?
Who owns those Pods?
Which Nodes are involved?
Are there obvious factual signals, such as missing endpoints or no ready Pods?

That is the kind of context kctx tries to assemble.

kctx trace service payments-api --namespace payments

For a namespace-level view:

kctx health namespace payments

For a focused resource view:

kctx explain pod api-xyz --namespace payments

And when you need a deterministic JSON snapshot for automation or incident review:

kctx dump namespace payments > payments-dump.json

The important constraint: read-only

kctx does not mutate Kubernetes resources.

It does not:

restart workloads
apply manifests
patch resources
delete anything
perform remediation
claim to know the root cause

That is not because remediation is uninteresting. It is because I think the context layer should be boring, auditable, and safe before anything else is built on top of it.

This becomes even more important when AI agents enter the picture.

If an agent needs Kubernetes context, I would rather give it a narrow read-only tool that returns structured facts than hand it broad cluster access and hope the prompt is enough of a safety boundary.

Kubernetes context for AI agents

One of the areas I am experimenting with is exposing kctx through the Model Context Protocol.

Current serve modes include:

kctx serve --mode mcp
kctx serve --mode mcp-sse

The MCP tools currently cover the same core context operations:

get_namespace_health
explain_resource
trace_service
get_pod_graph
dump_namespace

The idea is simple: let an AI assistant ask for Kubernetes context without giving it mutation capabilities.

No remediation.
No raw YAML firehose.
No root-cause guessing dressed up as certainty.

Just compact operational facts that can be used as evidence.

There is also an MCP/SSE release test guide for anyone who wants to try this with a local kind cluster, the released Helm chart, Online Boutique, ngrok, Codex, Claude Code, or ChatGPT Developer Mode:

https://github.com/lucasepe/kctx/tree/main/docs/kctx-mcp-sse-release-test-guide.pdf

Important note: the MCP/SSE endpoint is read-only, but built-in AuthN/AuthZ is not production-ready yet. Treat it as local-lab or trusted-network tooling for now, or put it behind an external access-control layer.

CRDs need semantics, not wishful thinking

Another design choice: kctx does not pretend that every custom resource can be understood generically.

Kubernetes discovery can tell you that a CRD exists. It cannot tell you what that CRD means operationally.

So kctx uses explicit adapters for ecosystem-specific resources. An adapter can translate a CRD into the same core model used by the rest of the project: resource identity, compact status, related entities, relations, signals, and graph nodes or edges.

The current adapter set includes:

Argo CD Application
Argo CD AppProject
cert-manager Certificate

That approach is slower than saying "we support every CRD", but I think it is more honest. If a tool is going to describe operational context, it should know what it is describing.

JSON first, because scripts and agents need contracts

The CLI and HTTP API emit versioned JSON by default.

Responses include a schema version and kind, for example:

{
  "schemaVersion": "kctx.io/v1alpha1",
  "kind": "NamespaceHealth"
}

The repository includes machine-readable JSON schemas under:

schemas/kctx.io/v1alpha1

That part may sound less exciting than graphs or agents, but it is one of the pieces I care about most.

If humans are the only users, text output can be enough. If scripts, CI systems, incident tooling, and AI agents are also users, the output needs a contract.

Data safety

kctx` is designed to provide operational context, not sensitive data.

It avoids returning raw manifests, Secret data, ConfigMap data, raw environment variables, logs, and workload metrics.

Supported outputs also pass metadata and Kubernetes messages through a small redaction policy for common secret-bearing keys and text patterns.

This is not a magic privacy shield, but it is an intentional boundary in the design.

A tiny example workflow

Install:

bash curl -fsSL https://raw.githubusercontent.com/lucasepe/kctx/main/install.sh | bash

Run against your current Kubernetes context:

bash kctx health namespace default kctx explain pod <pod-name> --namespace default kctx trace service <service-name> --namespace default kctx graph pod <pod-name> --namespace default --render mermaid kctx dump namespace default

Or run the read-only HTTP server:

bash kctx serve curl http://localhost:8080/health/namespace/default

Or install the in-cluster server with Helm:

bash VERSION=0.3.0 helm upgrade --install kctx \ "https://github.com/lucasepe/kctx/releases/download/v${VERSION}/kctx-${VERSION}.tgz" \ --namespace kctx-system \ --create-namespace

Then:

bash kubectl -n kctx-system port-forward svc/kctx 8080:8080 curl http://localhost:8080/health/namespace/default

What I am looking for

The project is still under active development. It is useful today, but I am still hardening packaging, production deployment guidance, auth boundaries for server mode, and client compatibility around MCP/SSE.

I would love feedback from SREs, platform engineers, Kubernetes operators, and people experimenting with AI-assisted operations.

In particular:

Does the output feel like useful operational context?
Are the signals too noisy, too sparse, or missing obvious facts?
Which CRDs would be most valuable to support next?
Does the JSON contract work for your scripts or internal tools?
Does the MCP interface fit how you want AI agents to inspect infrastructure?
Where does the install, Helm chart, or local test flow feel confusing?
What would make you trust a tool like this in a production debugging workflow?

If you try the MCP/SSE path, I am especially interested in:

OS and Kubernetes/kind version
AI client and version
transport used: localhost, port-forward, ngrok, or internal URL
whether the standalone smoke test passed
whether the AI client discovered and called the tools
any rough edges in the responses

The repo

GitHub:

https://github.com/lucasepe/kctx

If this idea resonates with you, a star would help the project reach more Kubernetes and platform people.

But even more useful: open an issue, tell me where the model feels wrong, or share a debugging scenario where structured context would have saved time.

That is the kind of feedback that can make kctx sharper.

An opinionated way to build and maintain complex YAML documents

Luca Sepe — Mon, 21 Mar 2022 19:56:41 +0000

`dirty` - Directory to YAML

Create YAML documents from a directory tree.

Build a YAML document from a directory tree containing YAML fragments.

It is useful everywhere complex YAML configuration is employed:

CI pipelines
Crossplane Compositions
Kubernetes manifests, etc.

For instance, Kubernetes resources can be complex, and in turn make the YAML very verbose.

The aim is to make the document easier to reason about and maintain.

How to use

dirty parses a directory tree:

a directory is a yaml key
a file (a yaml fragment) has content that is rendered at the current indentation level

Check this Crossplane Composition as example: https://github.com/lucasepe/dirty/tree/main/testdata/platform-ref-aws/cluster/eks

Here the repo link: https://github.com/lucasepe/dirty

Regards,
Luca

Watch and react to Kubernetes objects changes

Luca Sepe — Fri, 18 Mar 2022 12:47:11 +0000

The Kubernetes API server exposes a REST interface consumable by any client.

client-go is the official client library for the Go programming language. It is used both internally by Kubernetes itself (for example, inside kubectl) as well as by numerous external consumers: operators, higher level frameworks and many more.

Using this library you can write Go applications to access kubernetes' API Server and you can programmatically add, delete, modify, and check kubernetes resources.

client-go introduces different types of clients such as: RESTClient, Clientset and dynamic.Interface. All these clients make available the Watch verb, which offers an event interface that reacts to objects changes: add, update, delete, etc.

In all cases, the returned object is an implementation of watch.Interface that looks like this:

Let's implement a watcher for namespaces changes. The application will do these things:

attempts to begin watching the namespaces resource getting a watch.Interface on success
iterates all the events produced by the watcher
when an event is of type "namespace added" adds a custom label patching the namespace
when en event is of type "namespace deleted" greet the namespace gone

In this article I'll show you how to use RESTClient to watch and then react to namespaces changes.

Here the source code - you can grab all the code @ https://github.com/lucasepe/using-client-go.

package main


import (
  "context"
  "fmt"
  "time"


  corev1 "k8s.io/api/core/v1"
  metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
  "k8s.io/apimachinery/pkg/types"
  "k8s.io/apimachinery/pkg/watch"
  "k8s.io/client-go/kubernetes/scheme"
  "k8s.io/client-go/rest"
  "k8s.io/client-go/tools/clientcmd"
)

func main() {
  // Using the default configuration rules get the info 
  // to connect to the Kubernetes cluster
  configLoader := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(
    clientcmd.NewDefaultClientConfigLoadingRules(),
    &clientcmd.ConfigOverrides{},
  )

  // create the Config object
  cfg, err := configLoader.ClientConfig()
  if err != nil {
    panic(err)
  }

  // we want to use the core API (namespaces lives here)
  cfg.APIPath = "/api"
  cfg.GroupVersion = &corev1.SchemeGroupVersion
  cfg.NegotiatedSerializer = scheme.Codecs.WithoutConversion()

  // create a RESTClient
  rc, err := rest.RESTClientFor(cfg)
  if err != nil {
    panic(err.Error())
  }

  // utility function to create a int64 pointer
  i64Ptr := func(i int64) *int64 { return &i }

  opts := metav1.ListOptions{
    TimeoutSeconds: i64Ptr(120),
    Watch:          true,
  }

  // attempts to begin watching the namespaces
  // returns a `watch.Interface`, or an error
  watcher, err := rc.Get().Resource("namespaces").
    VersionedParams(&opts, scheme.ParameterCodec).
    Timeout(time.Duration(*opts.TimeoutSeconds)).
    Watch(context.TODO())
  if err != nil {
    panic(err)
  }

  // the patch data, just add a custom label
  pd := []byte(`{"metadata":{"labels":{"modified-by":"lucasepe"}}}`)

  // the patch type
  pt := types.MergePatchType

  // who did this patch?
  po := metav1.PatchOptions{
    FieldManager: "my-cool-app",
  }

  // here we iterate all the events streamed by the watch.Interface
  for event := range watcher.ResultChan() {
    // retrieve the Namespace
    item := event.Object.(*corev1.Namespace)

    switch event.Type {
    // when a namespace is deleted...
    case watch.Deleted:
      // let's say hello!
      fmt.Printf("- '%s' %v ...bye bye\n", item.GetName(), event.Type)

    // when a namespace is added...
    case watch.Added:
      fmt.Printf("+ '%s' %v  ", item.GetName(), event.Type)

      // try to patch it!
      err = rc.Patch(pt).Resource("namespaces").
        Name(item.Name).
        VersionedParams(&po, scheme.ParameterCodec).
        Body(pd).
        Do(context.TODO()).
        Error()
      if err != nil {
        panic(err)
      }

      fmt.Println(" ...patched!")
    }
  }
}

To see what the program does, open two terminal windows.

In the first terminal run the code as usual:

$ go run main.go

In the second terminal create a namespace using kubectl:

$ kubectl create namespace demo-system

In the first terminal you should see a new line like this:

+ 'demo-system' ADDED   ...patched!

Going back to the second terminal and typing:

$ kubectl describe namespace demo-system

Name:         demo-syste
Labels:       kubernetes.io/metadata.name=demo-system
              modified-by=lucasepe
Annotations:  <none>
Status:       Active


No resource quota.


No LimitRange resource

You can see that the program added a new label to to the newly created namespace.

Now deleting the namespace with:

$ kubectl delete namespace demo-system

Going to the program terminal, you should see a new line:

- 'demo-system' DELETED ...bye bye

Using the watch.Interface interface directly is actually discouraged.

For instance, since the server will close watch connections regularly, the ResultChan channel can be closed at any time (due to an io.EOF error).

There are helpers to re-establishing a watch at the last-received resourceVersion. RetryWatcher will make sure that in case the underlying watcher is closed (e.g. due to API timeout or etcd timeout) it will get restarted from the last point without the consumer even knowing about it.

But what if API server lost events because etcd erased all resource versions?

In order to be resilient to etcd cache not having the resource version anymore - you would need to use Informers.

If you want to discover much more about how to use the client-go library to do all kind of interaction with Kubernetes up to the step-by-step instruction about how to create a custom controller (operator) to manage your custom resource, you could eventually buy my notebook "Using client-go" here: https://leanpub.com/using-client-go - but take a peek first - download a free notebook excerpt with the TOC and some random page.

Thank you for your time!

All the best,

Luca

Craft beautiful geometric art using code.

Luca Sepe — Fri, 01 Jan 2021 11:06:34 +0000

Craft beautiful geometric art using code.

Use the code basics like loops, control flow and specialized functions to generate your geometry artworks.

Examples of g2D Geometry Art

Installation

Go get

$ go get -u github.com/lucasepe/g2d

Ready-To-Use Releases

Here you can find g2d already compiled for:

MacOS
Linux
Windows

How to use

To execute a local g2d script:

$ g2d /path/to/my-script.g2d

To execute a g2d script stored somewhere on the web:

$ g2d http://my-cool-site.com/remote/path/to/my-script.g2d

Use the --directory (or the shorter -d) flag to specify a destination folder for the generated PNG images.

The `g2D` Programming Language Syntax

Example-programs can be found beneath examples/ which demonstrate these things, as well as parts of the standard-library.

Types

g2D has the following data types: bool, int, float, str, array, and fn.

Type	Syntax	Notes
bool	`true false`
int	`0 42 1234 -5`	is a signed 64-bit integer
float	`0.5 4.2 1.234 -5.5`	is a 64-bit double-precision floating point
str	`"" "foo" "\"quotes\" and a\nline break"`	are immutable arrays of bytes
array	`[] [1, 2] [1, 2, 3]`	grow-able arrays (use the `append()` builtin)
fn	`fn(a, b) { ... }`	defines a custom function

Bindings

Variables are bounded using the := operator.

a := 3
b := 1.2

Variables may be integers, floats, strings, or arrays/hashes.

To update a variable you can simply specify the equals = operator:

a := 3    // Binding
a = a + 5 // Updating

Arithmetic operations

g2D supports all the basic arithmetic operation of int and float types.

a := 5
b := 3

c := a + b
d := c / 2
e := d * d

Builtin containers

g2d has one builtin containers: array.

Arrays

An array is a list which organizes items by linear sequence. Arrays can hold multiple types.

a := [1, 2.3, "hello!"]
b := [false, true, "Hello World", 3, 3.13]

Adding to an array is done via the push builtin function:

a = append(a, "another")

You can iterate over the contents of an array like so:

i := 0
while( i < len(a) ) {
    print( "Array index ", i, " contains ", a[i], "\n")
    i = i + 1
}

With the definition we included that produces this output:

Array index 0 contains 1
Array index 1 contains 2.3
Array index 2 contains hello!
Array index 3 contains another

Functions

g2D uses fn to define a function which will be assigned to a variable for naming/invocation purposes:

sum := fn(a, b) { return a + b }

print(sum(5,3), "\n")       // Outputs: 8
print(sum(2.5,7.5), "\n")   // Outputs: 10

Functions can be passed as values to others functions:

addTwo := fn(a, b, f) { 
    return 2 + f(a, b) 
}

tot := addTwo(68, 1, sum)
print(tot, "\n")            // Outputs: 71

Functions inside functions

multiplier := fn(q) {
    return fn(x) {
        return x*q
    }
}

multThree := multiplier(3)

print(multThree(2), "\n")  // Outputs: 6
print(multThree(3), "\n")  // Outputs: 9
print(multThree(4), "\n")  // Outputs: 12

If-else statements

g2D supports if-else statements.

max := fn(a, b) {
    if (a > b) {
        return a;
    } else {
        return b;
    }
}

print( max(1, 2) )  // Outputs: 2

Switch Statements

g2D supports the switch and case expressions:

switch n := randi(10) {
    case n % 2 == 0 {
        print(n, " is even", "\n")
    }
    default {
        print(n, " is odd", "\n")
    }
}

While Loops

g2D supports only one looping construct, the while loop:

i := 30
while (i > 0) {
    print(i, " ")
    i = i - 10
}
// 30 20 10

Builtin functions

Core

Function	Description
`exit([status])`	exits the program immediately with the optional status or 0
`input([prompt]`	reads a line from standard input optionally printing the specified prompt
`print(...)`	output a string to stdout
`printf(pattern, ...)`	output a string to stdout (formatted according the specified pattern)
`sprintf(pattern, ...)`	like `printf(...)` but returns a string
`bool(val)`	converts value to a bool
`float(val)`	converts decimal value str to float - if val is invalid returns null
`int(val)`	converts decimal value str to int - if val is invalid returns null
`str(val)`	returns the string representation of val
`len(iterable)`	returns the length of the iterable (string or array)
`append(array, val)`	returns a new array with value pushed onto the end of array

Calculation

Function	Description
`abs(x)`	returns the absolute value of x
`atan(x)`	returns the arc tangent, in radians, of x
`atan2(x, y)`	returns the arc tangent of y/x
`cos(x)`	returns the cosine of the radian argument x
`degrees(angle)`	converts radians into degrees
`hypot(p, q)`	returns `sqrt(pp + qq)`
`lerp(start, stop, amt)`	calculates a number between two numbers at a specific increment
`map(v, b1, e1, b2, e2)`	re-maps a number from one range to another
`max(v1....vn)`	returns the largest value in a sequence of numbers
`min(v1....vn)`	returns the smallest value in a sequence of numbers
`pow(x, y)`	returns `x**y`, the base x exponential of y
`sin(x)`	returns the sine of the radian argument x
`sqrt(x)`	returns the square root of x
`radians(angle)`	converts a degree measurement to its corresponding value in radians
`randf([min], [max])`	returns a random float between min and max - by default min=0.0 and max=1.0
`randi([min], [max])`	returns a random int between min and max

Basic graphic functions

Function	Description
`size(w,[h])`	sets the size of the drawing; when both w and h are specified creates a rectangular image otherwise creates a squared one
`viewport(xMin, xMax, yMin, yMax, xOffset, yOffset)`	sets up user-defined coordinate system; performs a screen reset (drawings are cleared)
`clear()`	fills the entire image with the current color; clear all drawings
`fillColor(hexcolor)`	sets the fill color to the specified hexcolor; example fillColor("#ff0000")
`fillColor(r, g, b, [a])`	sets the fill color to r,g,b,a values - should be between 0 and 255, inclusive
`strokeColor(hexcolor)`	sets the stroke color to the specified hexcolor; example strokeColor("#ff0000")
`strokeColor(r, g, b, [a])`	sets the stroke color to r,g,b,a values - should be between 0 and 255, inclusive
`strokeWeight(weight)`	sets the stroke thickness to the specified width
`dashes([s1, s2, ...sn])`	sets the current dash pattern to use (call with zero arguments to disable dashes)
`stroke()`	strokes the current path with the current stroek color and line width the path is cleared after this operation
`fill()`	fills the current path with the current fill color; open subpaths are implicity closed. The path is cleared after this operation
`fillAndStroke()`	fills the current path with the current fill color and strokes it with the current stroke color; the path is cleared after this operation
`push()`	saves the current state of the graphic context by pushing it onto a stack
`pop()`	restores the last saved graphic context state from the stack
`snapshot([filename])`	creates a PNG image with the current drawings. If filename is omitted, it will be autogenerated with a progressive counter, that will be incremented on each `snapshot()` invocation; this is useful if you wants to generate an animation later (using all the generated PNG images).
`xpos()`	returns the current X position (if there is a current point)
`ypos()`	returns the current Y position (if there is a current point)

Graphic primitives

Function	Description
`arc(x, y, r, sa, ea)`	draws a circular arc centered at (x, y) with a radius of r. The path starts at sa angle_, ends at ea angle, and travels in the direction given by anticlockwise
`circle(x, y, r)`	draws a circle centered at [x, y] coordinates and with the radius r
`ellipse(x, y, rx ,ry)`	draws an ellipse centered at [x, y] coordinates and with the radii rx and ry
`line(x1, y1, x2, y2)`	draws a line from point (x1, y1) to point (x2, y2)
`point(x, y)`	draws a point at specified coordinates (the size is equal to the stroke weight)
`quad(x1, y1, x2,y2, x3,y3, x4,y4)`	draws a a four sided polygon using the provided vertices
`rect(x, y, w, h, [tl, tr, br, bl])`	draws a (w x h) rectangle with upper left corner located at (x, y). If only one radius is specified, all the corners have the same bending, if tl, tr, br, bl are specified, each corner can have a different curvature
`triangle(x1,y1, x2,y2, x3,y3)`	draws a triangle using the provided vertices
`star(cx, cy, n, or, ir)`	draws a star cx, cy is the center, n the number of spikes, or and ir the outer and inner radius

Paths

Function	Description
`beginPath()`	starts a new path
`closePath()`	adds a line segment from the current point to the beginning of the current subpath
`moveTo(x, y)`	sets the begin of a new subpath starting at the specified x, y point
`lineTo(x, y)`	adds a line segment to the current path starting at the current point
`arcTo(x1, y1, x2, y2, r)`	adds a circular arc to the current sub-path, using the given control points and radius
`quadraticCurveTo(x1, y1, x2, y2)`	adds a quadratic Bézier curve to the current sub-path; x1, y1 is the control point and x2, y2 is the end point

Transform

Function	Description
`rotate(angle, [x, y] )`	updates the current matrix with a anticlockwise rotation; when x, y are specified, rotation occurs about this point, otherwise rotation occurs about the origin (angle is in radians)
`scale(sx, sy, [x, y])`	updates the current matrix with sx, sy scaling factor; when x,y are specified, scaling occurs about this point, otherwise scaling occurs about origin.
`translate(x, y)`	updates the current matrix with a translation to x and y
`identity()`	resets the current transformation matrix to the identity matrix
`transform(x, y)`	multiplies the point x, y by the current matrix, returning a transformed position

Text

Function	Description
`text(str, x, y, [ax, ay])`	draws the specified text str at the specified anchor point x, y; the anchor point is x - w ax, y - h * ay, where w, h is the size of the text (by default ax=0.5, ay=0.5* to center the text at the specified point)
`textWidth(str)`	returns the rendered width of the specified text str given the current font face
`fontSize(size)`	sets the font height

Images

Function	Description
`imageGet(path/to/png)`	loads a PNG image from the local filesystem
`imageAt(im, x, y, [ax, ay])`	draws the specified image im at the specified anchor point x, y; (ax and ay are the x and y offsets) use ax=0.5, ay=0.5 to center the image at the specified point

Create (not just) diagrams stitching images on a grid using HCL (like terraform!)

Luca Sepe — Sun, 09 Aug 2020 06:25:25 +0000

   _           _   _
  |_|_ _ _____| |_| |___     
  | | | |     | . | | -_|   
 _| |___|_|_|_|___|_|___|            
|___|

https://github.com/lucasepe/jumble

Create (not just) diagrams stitching, connecting and labelling
images on a grid using HCL syntax (like terraform!).

515 Embedded cloud architecture icons! Ready to use!

225 AWS icons (uri = assets://aws_[KIND])
182 Azure icons (uri = assets://azure_[KIND])
108 Google Cloud icons (uri = assets://google_[KIND])

# AWS Lambda Authorizer
tile "icon" "lambda1" {
    row = "${subtract(row("agw"), 1)}"
    col = "${subtract(col("agw"), 2)}"
    uri = "assets://aws_lambda"
}

or you can use your local icons (uri = /path/to/my/ic.png)
or you can use remote icons (uri = http://a.domain.com/img/ic.png)

A commandline tool that generate High Level microservice & serverless Architecture diagrams

Luca Sepe — Sat, 06 Jun 2020 07:14:43 +0000

A commandline tool that generate High Level microservice & serverless Architecture diagrams using a declarative syntax defined in a YAML file.

https://github.com/lucasepe/draft

Why?

to quickly scketch HL Arks
- to change the diagrams without pain (point, click drag..etc.)
- to share diagrams using just a plain YAML file
- the "terminal" is my playground :-D
- but..above all..to do something funny and relaxing in Go!

Please check it out and let me know what do you think!

All the best,
Luca

Maps in Go

Luca Sepe — Sat, 30 May 2020 07:35:50 +0000

Slices in Go

Luca Sepe — Wed, 27 May 2020 16:56:13 +0000

A Simple Overview of Arrays in Go

Luca Sepe — Tue, 26 May 2020 16:34:39 +0000

Pointers in Go

Luca Sepe — Tue, 26 May 2020 06:37:46 +0000

Structs types in Go

Luca Sepe — Sat, 23 May 2020 15:53:02 +0000

Constant and Variables

Luca Sepe — Sat, 23 May 2020 15:50:47 +0000

DEV Community: Luca Sepe

I'm building a read-only context engine for Kubernetes and AI agents

The short version

Why another Kubernetes tool?

The important constraint: read-only

Kubernetes context for AI agents

CRDs need semantics, not wishful thinking

JSON first, because scripts and agents need contracts

Data safety

A tiny example workflow

What I am looking for

The repo

An opinionated way to build and maintain complex YAML documents

dirty - Directory to YAML

How to use

Watch and react to Kubernetes objects changes

Craft beautiful geometric art using code.

Craft beautiful geometric art using code.

Examples of g2D Geometry Art

Installation

Go get

Ready-To-Use Releases

How to use

The g2D Programming Language Syntax

Types

Bindings

Arithmetic operations

Builtin containers

Arrays

Functions

If-else statements

Switch Statements

While Loops

Builtin functions

Core

Calculation

Basic graphic functions

Graphic primitives

Paths

Transform

Text

Images

Create (not just) diagrams stitching images on a grid using HCL (like terraform!)

A commandline tool that generate High Level microservice & serverless Architecture diagrams

Maps in Go

Slices in Go

A Simple Overview of Arrays in Go

Pointers in Go

Structs types in Go

Constant and Variables

`dirty` - Directory to YAML

The `g2D` Programming Language Syntax