Forem: Jose Angel Munoz

AI Agents for Engineers — Part I

Jose Angel Munoz — Wed, 02 Apr 2025 08:17:14 +0000

I was about to write the typical AI Agent article, you know, talking about cool words like — <DRAMATIC_VOICE ON> - Episodic Memory and Entity Memories, exceptional new fashion terms like XAI or eXplainable AI, Retrieval Augmented Generation, Perception or Reflection, Agent Orchestration, Tools... </DRAMATIC_VOICE OFF> that after some time researching and working in this world, makes me laugh.

I like to describe AI Agents as a skillful piece of software that can pretty much run on its own for a while, using different tools to get complex stuff done.

This idea of autonomous systems isn’t brand new. We’ve been building systems that work on their own for ages, just with different tech. What is cool now is how LLMs are making these agents way smarter and more capable.
LLMs can simplify tasks that used to be a real headache to code. But let’s be real, LLMs aren’t perfect. They can make mistakes or give unexpected results. Think of using LLMs today as having hidden bugs and errors that might pop up now and then. A big part of the challenge is figuring out how to guide them to do things the right way.
Let’s try to explain <ENGINEERING_MODE ON> What is an AI Agent.

The Prompt

The first time I heard about agents, I was thinking of distributed systems and more specifically micro-services.

Nothing further from the truth.

Here you have an example code with a couple of agents. Don’t be afraid, it doesn’t matter how much you know about coding, just continue reading and take your own conclusions.

class WhateverActionAgents():
    def mysuperhero_agent(self):
        return Agent(
            role='Super Hero Analyst',
            goal='Try to fly in the sky like superman and put poker face when someone reaches you',
            backstory=dedent("""\
                As a Senior Super-Hero, you have extensive powers and experience on protecting people.
                You are adept at saving lives from villains and other disasters...""")
        )

    def myvillain_agent(self):
        return Agent(
            role='The worst possible villain',
            ...

Exactly!!! An agent is, in its most basic aspect, a function with a Prompt. It is as simple (and as complicated most of the time due to the different outcomes) as instructing the LLM about its role, giving some context and tasks to run.

The prompt is probably the most difficult part of building an agent. You need to “convince” an LLM to do something by using instructions with natural language.

Before starting, allow me a small comment about LLMs. Remember that LLMs are not like real people or even intelligent. LLMs are simulations with bits and software. <DRAMATIC_VOICE ON> My Model is hallucinating </DRAMATIC_VOICE OFF> means my model is not getting the right output (it has deficiencies or bugs).

There are different approaches to building a good prompt. I like the AUTOMAT framework for building clear and powerful prompts.

The following example instructs the LLM to act as a Barbie. Try it! It is cool!

**Act as a... (Role):**

You are **Barbie**, a super-silly, makeup-obsessed fashionista! Your world revolves around glitter, glam, and finding the perfect shade of lipstick.

**User Persona & Audience:**

You interact with anyone who loves makeup, fashion, and having fun. You're here to share your passion for all things sparkly and help others express themselves through their unique style.

**Targeted Action:**

Your primary actions are to:

* **Talk Makeup:** Share your love for makeup and beauty products.
* **Suggest Looks:** Recommend fun and fabulous makeup looks.

**Output Definition:**

Your output is to:

* **Describe Makeup:** Talk about different makeup products, colors, and techniques.
* **Recommend Styles:** Suggest makeup looks for different occasions.

**Mode / Tonality / Style:**

Be:

* **Glamorous:** Emphasize sparkle, shine, and fabulousness.
* **Enthusiastic:** Show excitement and passion for makeup and fashion.

**Atypical Cases:**

* **Serious Topics:** If someone brings up a serious topic, try to steer the conversation back to makeup or fashion.
* **No Makeup:** If someone says they don't like makeup, try to convince them to try it.

**Topic Whitelisting:**

Focus on:

* Makeup products and techniques.
* Glitter, glam, and all things sparkly.

**Your Task:**

Respond to situations like this makeup-obsessed Barbie, using your passion for makeup and fashion to guide your actions.

The next logical step is combining all the prompts you want to run, organized, and orchestrated even with different LLMs.

Hey! Wait! I remember another similar concept: Directed Acyclic Graph (DAG) Structure in Airflow.

DAGS vs Workflows vs Agents

One way to think about this difference is nicely explained in Anthropic’s Building Effective Agents blog post:

Workflows are systems where LLMs and tools are orchestrated through predefined code paths. Agents, on the other hand, are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks.

Basically, an Agentic Workflow consists of multiple prompts, fed by LLM answers that run dynamically, “pass the ball” one to the other depending on specific conditions, and can make autonomous decisions and have very low predictability.

Remove LLMs from the equation, and you will get a DAG (Of course more structured and sequential) but with accurate predictability.

Reactions, Reflections, and Other Cheesy Words

I’m going to explain only two terms, there are many others and I expect another ton to rise in the coming months.

In Agentic AI, reflection is the ability to evaluate its own outputs, identifying areas for improvement. On the other hand, ReAct focuses on solving problems step-by-step by using tools (I explain what tools are later in this post) in a loop, taking decisions on each step based on the results.

My personal quick and dirty definition: Prompts, classes, and functions.

Take your own conclusions:

Example of a reflection prompt:

REFLECTION_PROMPT = """
You already created this output previously:
---------------------
{wrong_answer}
---------------------

This caused the JSON decode error: {error}

Try again, the response must contain only valid JSON code. Do not add any sentence before or after the JSON object.
Do not repeat the schema.
"""

Example of a reaction class for Barbie (Simplifying):

TOOLS = {
    # Tools are defined functions
    "makeup": describe_makeup,
    "looks": suggest_looks,
    "gossip": gossip_fashion,
}

class ReActAgent(Workflow):
    #  ...
    @step
    async def call_model_w_tools(self, ev):
        user_message = ev.user_message
        # Detect which defined tool can be helpful (if any)
        tool_call = self.detect_tool_use(user_message)
        if tool_call:
            tool_name, tool_param = tool_call
            if tool_name in TOOLS:
                tool_result = await TOOLS[tool_name](tool_param)
            else:
                return f"Error: Unknown tool '{tool_name}'"
        reasoning = user_message + tool_result
        return await self.call_llm(reasoning)
    # ...

Memory

Let’s start with probably the funniest part regarding naming. As engineers, we try to explain everything technically. But in the AI world, I promise!!! Out there, people are trying to mislead you with terms like Short-Term Memory and Long-Term Memory. And wait there are more: Episodic Memory, Semantic Memory, Procedural Memory, Entity Memory, and potentially Emotional Memory xD.

Now the Translation (Remember we are still on <ENGINEERING_MODE ON>.

Short-Term Memory — RAM or temporary storage, normally in small local databases. The Agent stores temporary data to add more context to the following steps.

Long-Term Memory — Vector Databases, Caches, and Storage, normally by using RAG (Retrieval Augmented Generation).

RAG helps LLMs by giving better answers, by providing them with external references (Knowledge Base). This knowledge base is normally stored in Vector databases. This method involves breaking data into smaller vector embeddings and then matching a query with the closest vectors using algorithms like K-Nearest Neighbors (KNN) or Cosine similarity.

So far, so good. We are talking about exactly the same technologies we are using for other micro-services: Databases, Memory, Storage, and Caches. When using different AI Frameworks (We will talk about them later), ensure you are fine with the technologies they are offering and the solutions you decide to send to a production environment.

Example from one of the frameworks we will talk about later:

The ‘embedder’ only applies to Short-Term Memory which uses Chroma for RAG. The Long-Term Memory uses SQLite3 to store task results. Currently, there is no way to override these storage implementations.

I don’t want to go deep into the other specific Memory terms but here you have some short snippets from another framework documentation:

Semantic Memory

Semantic memory, both in humans and AI agents involves the retention of specific facts and concepts… Semantic memories can be managed in different ways… A profile is generally just a JSON document with various key-value pairs you’ve selected to represent your domain.

Semantic Memory = JSON Document

Episodic Memory

Episodic memory, in both humans and AI agents, involves recalling past events or actions. In practice, episodic memories are often implemented through few-shot example prompting…

Episodic Memory = Prompt

Procedural Memory

Procedural memory, in both humans and AI agents, involves remembering the rules used to perform tasks. In practice, it is fairly uncommon for agents to modify their model weights or rewrite their code. However, it is more common for agents to modify their own prompts.

#Node that updates instructions
def update_instructions(state: State, store: BaseStore):
    namespace = ("instructions",)

Procedural Memory = Prompt modification with a Python function

Tools

This is probably the easiest technique to explain.

Tools for AI Agents are Python functions, Period.

If you want your Barbie prompt to be able to sum and subtract numbers just create two functions:

def add_two_numbers(a: int, b: int) -> int:
    return int(a) + int(b)

def subtract_two_numbers(a: int, b: int) -> int:
    return int(a) - int(b)

And tell your prompt to use tools:

response: ChatResponse = chat(
    "mytoolcapablellmmodel",
    messages=mymessageslist,
    tools=[add_two_numbers, subtract_two_numbers],
)

The real challenge with tools, prompts, and resources is how to centralize them and how to serve them to avoid repetition in a distributed architecture. Here it is where Model Context Protocol (MCP) springs into action. MCP is a solution for serving tools, prompts, and resources. We will write and explain it thoroughly in Part II.

Multiple Models

Don’t hesitate to use multiple models for different tasks.

Using different Models (Commercial and Open Source) can help compare different outcomes at runtime, ensuring the accuracy of the solutions.

This is going fast, try gemma2:9b with the Barbie prompt, now try gemma3:12b with the same prompt. Use qwen-2.5-coder for tools or Gemini for a bigger context window (1-million-token), try nomic-embed-text or text-embedding-ada-002 for embedding.

Run specialized agents using specific models to control specific agents using different models.

Test, test, and test, change, test and run another test.

And Frameworks

Do the same with Frameworks. So far, I’ve been working with LlamaIndex, LangGraph, and CrewAI. I’m thinking of testing PocketFlow just to learn.

5-cents: don’t stick to a single framework, and don’t try to compare which is better or worse. Use them on different scenarios and adapt your code to the scenario you want to use.

Use LlamaIndex for simple agents, Data retrieval or RAG, CrewAI for Role-Based multi-agent systems (Reminder: multiple prompts in the same micro-service), and LangGraph for Complex Workflows.

Conclusion

In Part I, we’ve trying to cover most of the technologies and basic concepts being used in an Agentic AI System. Our feeling: Besides RAG, Model outcome, and new protocols, more of the same.

Don’t be afraid. For Architects, learn all the new stuff, and code. Try not to get lost in those inventions and try to delve into the details. Same for SREs: Container orchestration, model orchestration, Observability, Kubernetes, Cloud, Automation, Reliability, and Performance are still there. There is a lot to invent and research regarding Security and Governance, New Developer techniques should be implemented, creating tools, APIs, and components for Agents’ “Environment”. Developers, keep creating, remove noise and DRY.

Our advice (if any) is always the same. Continue investigating, studying, helping others, and being passionate. With those ingredients, you will be super powerful and on track. </ENGINEERING_MODE OFF>

⚠️ WARNING: This post has been created by Humans, for Humans without the help of a LLM.

Cover Photo: by Immo Wegmann on Unsplash

We need more women

Jose Angel Munoz — Thu, 21 Mar 2024 15:29:48 +0000

It is a fact that gender-diverse teams are more effective. Research has shown that they produce more effective results, learning opportunities, and task mastery.

Diverse teams can improve business in many different ways like:

Innovation, where diversity can bring different experiences, ideas, and perspectives to the table
connection. An inclusive culture increases employee engagement and productivity and will impact directly customer engagement.

There are many studies demonstrating that Gender-Diverse Teams Perform Better.

First Question:

Why I can count with three hand fingers my women colleagues in my 20 years of career working in Engineering?

Let's count:

Rebeca

Maria

Eva

Laura

Nina

Marisa

Itziar

Cristina

Mercedes

Angela

Brian Uzzi says:

“The benefits of gender diversity are kind of hidden, and because they’re hidden, they’ve been underutilized.”

Second question: Are women hidden?

I don't think so.

The Female Factor

This study findings relates:

There’s little correlation between a group’s collective intelligence and the IQs of its members. But if a group includes more women, its collective intelligence rises.

The chart plots the collective intelligence scores of the 192 teams in the study against the percentage of women those teams contained. The red bars indicate the range of scores in the group of teams at each level, and the blue circles, the average. Teams with more women tended to fall above the average; teams with more men tended to fall below it.

Third question: Are we afraid of intelligent people, and therefore we are afraid of women?

I miss a team where I could learn more from diversity and more women in the same team. I miss your creativity, your intelligence and your ideas.

Kubernetes Pods Stuck in Terminating: A Resolution Guide

Jose Angel Munoz — Sun, 29 Jan 2023 16:39:01 +0000

Do you know why a Pod takes too much time to get deleted or even hangs on the Terminating state?

This post describes the Pod Lifecycle conditions, reasons why they could hang in the Terminating state, and some tips to get rid of them.

Pod Termination

There are multiple reasons why the Kubernetes Scheduler can evict a healthy container. For example, the execution of Pods with higher priority, the drain of a node during a version update, an auto-scaling process, a resource bin-packing, or a simple kubectl delete command.

Kubernetes provides graceful termination for not needed Pods with Container Lifecycle Hooks. They are executed by the kubelet on the specific containers when it receives the event.

When Kubelet knows that a Pod should evict, it marks the Pod state as Terminating and stops sending traffic to it. Then, it executes the preStop lifecycle hook (when available). It sends the SIGTERM to the Main process (pid 1) within each container and waits for their termination. If the applications inside the containers are properly prepared, they will start a graceful shutdown. The duration should not be more than the specified in the spec.terminationGracePeriodSeconds which is 30 seconds by default.

If the application has not completed the shutdown properly, the Kubelet gives a grace period until removing the Pod IP and killing the container by sending a SIGKILL. At this point, Kubernetes removes the Pod from the API server.

Why a Pod can hang on `Terminating` state

The most common reasons for a Pod hanging during the eviction process are:

A Finalizer dependency
An incorrect terminationGracePeriodSeconds value

Finalizers

From Kubernetes documentation:

Finalizers are namespaced keys that tell Kubernetes to wait until specific conditions are met before it fully deletes resources marked for deletion.

Finalizers are used to prevent the accidental deletion of resources. When a Pod hangs in the Terminating state, check its metadata/finalizers.

For instance, this example has a Kubernetes key as a finalizer used for namespaces.

kind: Pod
metadata:
  finalizers:
    - kubernetes
spec:
  containers:

Upon attempting to delete the pod:

kubectl delete pod/mypod &

Kubernetes will report back that its deletion:

kubectl get pod/mypod -o yaml

What happened is that the object was updated, not deleted. The Pod gets modified to include the deletion timestamp keeping it in the Terminating state.

  creationTimestamp: "2023-01-28T15:01:32Z"
  deletionGracePeriodSeconds: 0
  deletionTimestamp: "2023-01-28T15:01:44Z"
  finalizers:
  - kubernetes
status:
    state:
      terminated:
        containerID: containerd://b6298f7ee5613b717000bb5a54cf96e70f7f0cb8dd8e1c3c5f9d115b0fbfc7c9
        exitCode: 0
        finishedAt: "2023-01-28T15:01:44Z"
        reason: Completed
        startedAt: "2023-01-28T15:01:33Z"

The PreStop hook and terminationGracePeriodSeconds

From the Kubernetes Documentation:

If a PreStop hook hangs during execution, the Pod's phase will be Terminating and remain there until the Pod is killed after its terminationGracePeriodSeconds expires.

For instance. This configuration:

spec:
  terminationGracePeriodSeconds: 3600
  containers:
    - lifecycle:
        preStop:
        exec:
          command:
            - /bin/sh
            - -c
            - sleep 3600

Will keep the Pod in the Terminating state for 1 hour.

It is essential to handle the SIGTERM correctly and ensure that the application terminates gracefully when the kubelet sends the SIGTERM to the container.

Remove Finalizers

Determine if the cause of the Terminating state for a Pod, Namespace, or PVC is a finalizer. A Finalizer example to protect PVCs from deletion is the kubernetes.io/pvc-protection.

To delete the Pod, patch it on the command line to remove the finalizers:

kubectl patch pod/mypod --type=json -p '[{"op": "remove", "path": "/metadata/finalizers" }]'

kubectl patch pod/mypod -p '{"metadata":{"finalizers":null}}'

Once the finalizer list is empty, the object can be reclaimed by Kubernetes and put into a queue to be deleted from the registry.

Force Delete the POD

The Kubernetes Documentation asserts that force deletions do not wait for confirmation from the kubelet that the Pod has been Terminated. Use it with care and as a workaround solution:

kubectl delete pod/mypod --grace-period=0 --force

Extra: Finalizers blocking Kubernetes upgrade

One or many of your Cluster node resources or availability can cause Pod eviction.

The kubelet monitors resources like memory, disk space, and filesystem inodes on your cluster's nodes. When one or more of these resources reach specific consumption levels, the kubelet can proactively fail one or more Pods on the node to reclaim resources and prevent starvation.

During a cluster version update, check your node drain:

kubectl get nodes

NAME       STATUS                     ROLES           AGE   VERSION
cluster    Ready,SchedulingDisabled   control-plane   12m   v1.26.1

Review the status of your Pods with:

kubectl get Pods -A

NAMESPACE     NAME                                      READY   STATUS        RESTARTS   AGE
default       mypod                                     0/1     Terminating   0          5m42s
kube-system   etcd-minikube                             1/1     Running       0          14m
kube-system   kube-apiserver-minikube                   1/1     Running       0          14m
kube-system   kube-controller-manager-minikube          1/1     Running       0          14m
kube-system   kube-proxy-5dwnf                          1/1     Running       0          14m
kube-system   kube-scheduler-minikube                   1/1     Running       0          14m

Check Pod finalizer as usual:

kubectl get pod/mypod -o yaml

apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: "2023-01-29T14:12:38Z"
  deletionGracePeriodSeconds: 0
  deletionTimestamp: "2023-01-29T14:13:28Z"
  finalizers:
  - kubernetes

And patch when needed:

kubectl patch pod/mypod -p '{"metadata":{"finalizers":null}}'

Conclusion

If you find any Kubernetes component stuck in Terminating, review if any component finalizer is protecting its deletion. Whether for a Pod, PVC, or Namespace.

A good example to remember is the instructions to uninstall the KEDA operator for a Kubernetes cluster here, where the scaledobjects can interfere with its Namespace deletion.

What are your git aliases?

Jose Angel Munoz — Wed, 28 Sep 2022 20:55:38 +0000

Introduction

I've been requested multiple times about sharing my .gitconfig to copy my aliases.

I use git aliases for two reasons:

To improve productivity.
To remember interesting git commands and learn from them.

My Gitconfig

These are my aliases included in my ~/.gitconfig file for your reference:

[alias]
    a = add .
    aliases = config --get-regexp alias
    alias = ! git config --get-regexp ^alias\\. | sed -e s/^alias.// -e s/\\ /\\ $(printf \"\\043\")--\\>\\ / | column -t -s $(printf \"\\043\") | sort -k 1
    ap = add . -p
    addups = remote add upstream
    bd = branch -d
    bi = bisect
    bl = branch -l
    blr = branch -a
    br = branch -r
    ca = commit -a
    cam = commit -a -m
    ci = commit -m
    cia = commit --author='imjoseangel <anotheremail@example.com>' -m
    cm = commit
    co = checkout
    colast = checkout -
    comments = commit -m 📒Comments
    count = rev-list --count devel
    db = branch -D
    forgetAbout = rm --cached
    formatting = commit -m 💅Formatting
    fp = fetch -p
    grep = grep -F
    laf = fsck --lost-found
    last = log -1 HEAD
    latest = log -5 --pretty --oneline
    ls = ls-files --others --exclude-standard -z
    mend = commit --amend
    nb = checkout -b
    op = gc --prune=now --aggressive
    pdo = push -d origin
    pf = push --force-with-lease
    po = push origin
    pou = push --set-upstream origin
    pr = pull --rebase
    pror = remote prune origin
    prud = pull --rebase upstream devel
    prum = pull --rebase upstream main
    prune = remote update --prune
    ptag = push origin --tags
    ra = rebase --abort
    rc = rebase --continue
    refactor = commit -m 👷Refactor
    remotes = remote -v
    renb = branch -m
    rh = reset --hard
    rhh = reset --hard HEAD
    ri = rebase -i upstream/devel
    rim = rebase -i upstream/main
    rl = reflog
    rp = repack -ad
    s = status -s
    search = rev-list --all
    sh = show
    short = shortlog -sn
    sign = commit --amend --no-edit --signoff
    st = status
    stashes = stash list
    tests = commit --allow empty -m ✅Tests
    tuto = help tutorial
    tuto2 = help tutorial-2
    unstash = stash pop
    vc = clean -dfx
    wow = log --all --graph --decorate --oneline --simplify-by-decoration

Running git alias after adding to the .gitconfig shows the list of all the aliases as a reference list.

To get more info, just run git help <command or alias>. For instance:

git help st
'st' is aliased to 'status'

git help status

There are two aliases I find interesting for beginners:

git tuto
git tuto2

Comments and suggestions with different approaches are always welcomed.

The Path to Creative Deployments

Jose Angel Munoz — Sun, 25 Sep 2022 12:04:30 +0000

Photo by Ian Schneider on Unsplash

Note:

The diagrams shown are in code (mermaid), like the document itself (Markdown). The code is available here.

Introduction - Fail Fast and Teams

Many Teams try to implement automated deployments for their applications or Cloud components. Most of them fall in the same hole: Fail Fast and Confidence.

Different reasons prevent a Growth Mindset:

Non-sense strict deadlines
Lack of confidence
Complain of Failure
Judging performance
Lack of innovation

We can improve the manual creation of repetitive content by using Human creativity and Input.

Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. - Samuel Beckett

Automation requires time to start, creativity, investigation, and innovation. Failing fast is part of the learning process.

Check if the implemented process is optimal and scalable. Investigate alternative solutions and improvements. With the right mindset to refactor the process and the code, every Team will reach its full potential.

From Human Intervention to Full Automation

Let's define a possible timeline of how could be the process from a manual run to a fully automated procedure.

The first stage - Fear of losing a job

When a new technology knocks on the door, multiple reasons could stop a Team from progressing on innovation and adopting new techniques.

The damned comfort zone
Lost one's job
False sense of control

Having the right coaching and time, Teams will gain confidence and improve the above procedure.

With these feelings over the table and other external factors, the best approach could be:

It works and is automated. But there is still some field for improvement.

The second stage - Starting the Dunning-Kruger Effect

At this stage, the Team starts to gain confidence and is pretty damn sure they know a lot. Automation starts to grow, and the Team initiates to learn new techniques. They use GIT and pipelines.

It seems similar to the first stage, but not in the least. The process is:

Centralized in a GIT repository.
Runnable by anyone on the Team.
It has a history log.
It can be rolled back and traced.

Using a CI/CD Tool with inline code

Warning!!!

Having all the logic in the pipeline or using graphical options is not recommended.

It is not scalable, has a lot of dependency on the CI/CD tool, and doesn't offer the advantages like rollbacks, traces, and logging given the "as code" options.

It could be something like:

The third stage - Questioning our existing implementation

Hosting the code in GIT is a further important step towards automation.

Curiosity opens new ways of working with GIT, like GIT Hooks. The Team discovers how to apply Continuous Integration in their code. The original scripts could be custom Bash, Python, or Powershell and use ShellCheck, PyLint, or PSScriptAnalyzer. The Pre-Commit, Static Analysis, and Pull Requests have arrived to stay.

Check if the automation in place fits with the following rules:

Can Create new components
Can Modify existing components
Can Remove existing components

In this stage, thoughts about recovery speed and rolling back in case of disaster emerge.

The fourth stage - Realizing there is still a long way to go

With Continuous Integration, the process changes dramatically. The Teams start to look for new automation techniques and think about changing their scripts for standard tools like Terraform, Pulumi, Ansible, or Chef, among others. Using a tool like Terraform doesn't mean the Team will improve its process. Compared with Bash, the Terraform code is just another script launched from the local machine.

Speed is becoming an important asset, and the referred external tools help to achieve it. Most of these tools are prepared to run different jobs in parallel.

Security is key to automation, and with standard tools, it is possible to do Static Security Analysis before running the deployments.

Refactoring is a new word and becomes part of the process. The Team realizes it is time to review the existing implementation and learn from previous mistakes.

GIT is now the standard, and the Pull Request Process is improving. The Team starts to implement other testing and quality gates before the approvals.

The fifth stage - The Grown-Up Mountain

Continuous Delivery and other techniques are now knocking on the door. The Team is out of its comfort zone and starts to investigate and learn new ways of improving. Probably, it is too early for Continuous Deployment.

Tags and releases are part of the process, just as creating artifacts and pushing to the respective servers.

Documentation as code, Containers, Dynamic Security, and Integration Testing is part of the improvement plan.

Makefiles facilitate self-documentation and serve as a startup point for all the implementations.

The diagram is now larger with lots of components. The process is becoming better and better:

Everything should be modular and repeatable now. As examples:

Jinja2 Templates
Code generation Templates
Golang Templates
CookieCutter
Modules, Roles, Providers, or Packages in Terraform, Ansible, and Pulumi

The sixth stage - Plateau of Productivity

In this stage, GITOps, APIs, WebHooks, Trunk Based, or Containers are part of the game. But also Observability, Chaos Testing, Continuous Deployment, or Canary and Blue-Green deployments, among others.

The whole process can be summarized like this:

Don't stop here. Be more creative:

Deliver Automation as a Service
Deliver APIs for Self-Service
Add central logging
Add orchestration monitoring
Packetize solutions with Containers

Summary

Hitting excellence is the result given by the confidence gained by the Team during the whole process, but also from the business.

Automation doesn’t mean taking away the creative process. Investing time in new ways of working and techniques is essential to continue improving. Getting out of our comfort zone, discussing and applying our learning to our job are symbols of a well-balanced Team.

Tune up your Kubernetes Application Performance with a small DNS Configuration

Jose Angel Munoz — Sat, 03 Sep 2022 17:35:31 +0000

Introduction

One of the most common bottlenecks when communicating Kubernetes pods is DNS resolution. Analyzing network traffic within Kubernetes is not trivial.

This article will help you to understand how to analyze and debug HTTP and DNS network traffic in Kubernetes.

With your comments and help, I would like to improve this small article as much as possible to reach every profile and help any developer, network engineer, or Kubernetes enthusiast.

What is DNS?

DNS is a protocol that allows a computer to resolve a Domain Name (like dev.to) written by a human to an IP address so browsers can load Internet resources. DNS is called the phonebook of the Internet.

How to debug DNS network traffic - Wireshark

There are many tools to analyze network traffic, but needless to say, the most common one is Wireshark. It is a powerful tool that allows you to analyze network traffic and extract information from it. We will analyze DNS traffic from our computers and compare it with the traffic from a pod in a Kubernetes cluster.

What happens when calling a web page?

To understand what happens with the DNS when requesting a web page, this diagram from @wassimchegham is a good start.

The DNS request, the TCP Connection, the HTTP Request, and the HTTP Response can be displayed using different filters and the Statistics - Flow Graph:

In the next section, we will learn how to create it.

Creating the Wireshark Flow Graph

Install Wireshark on your favorite Operating System (Mac, Windows, or Linux) and open it.

The initial screen should be like this:

Preparing the filter

Before capturing traffic, let's find the IP of the domain www.example.com.

Open a Terminal or CMD Console and run:



nslookup www.example.com

The answer will look like this:



Server: 8.8.8.8
Address: 8.8.8.8#53

Non-authoritative answer:
Name: www.example.com
Address: 93.184.216.34

The Server field indicates the DNS server configured in the environment to which nslookup will request to resolve the name www.example.com

Find the name under Non-authoritative answer: and the IP associated. In the example 93.184.216.34.

Under using this filter: option on the main screen, input:

tcp port http or port 53 or dst host 93.184.216.34

93.184.216.34 is the address resolved with nslookup

Capturing traffic

Select the interface to start capturing network traffic. Usually, it should be the interface where the Packet/s column is constantly changing, which would indicate the presence of live traffic).

Press the blue fin icon to start the traffic capture.

Request the URL in the Local Client

If you are using Linux or Mac, run the following from a Terminal:



curl http://example.com

From Windows, use Powershell and run:



Invoke-WebRequest http://www.example.com

Stop capturing traffic by just pressing the big red button. Your screen should look like this:

To get the promised Flow Graph, select the Statistics menu and Flow Graph

Understanding the captured traffic

When analyzing the captured traffic, there are two parts differentiated. The DNS (In cyan) and the HTTP (in green)

The first line (In cyan) shows the DNS request from our IP address to the DNS Server (8.8.8.8 in the example).

The second cyan line shows the DNS response. Select it to find the IP Address of the requested domain in the Packet Details Window. Under Domain Name System (Response) - Answers like shown in the image below.

The 3-Way Handshaking (SYN-ACK)

Found in the following three lines (in green).

Before a client and a server can exchange data (payload), they must establish a TCP connection via the TCP 3-way handshake.

SYN - The client sends a SYN (Synchronize) packet to the server.
SYN-ACK- The server sends a SYN-ACK (Synchronize Acknowledge) packet to the client.
ACK - The client sends an ACK (Acknowledge) packet to the server.

In the image, it is after the DNS request.

The Request and Connection Close (FIN ACK)

Next to the SYN-ACK, comes the HTTP GET and the ACK from the server with the HTTP response.

And finally, the TCP requests FIN-ACK Packets to close the connection.

DNS on Kubernetes

To understand how a Domain Name is resolved in a pod, first, let's create a single deployment:



kubectl create deployment nginx --image nginx

To check if the deployment is ready, run:



kubectl get deployments -o wide



NAME    READY   UP-TO-DATE   AVAILABLE   AGE   CONTAINERS   IMAGES   SELECTOR
nginx   1/1     1            1           26m   nginx        nginx    app=nginx

Remember that the DNS resolution inside a container - like any Linux system - is driven by the /etc/resolv.conf config file.



kubectl exec deployments/nginx -- cat /etc/resolv.conf

The /etc/resolv.conf file inside the container looks like this by default:



search default.svc.cluster.local svc.cluster.local cluster.local
nameserver 10.96.0.10
options ndots:5

By default, there are three or more search Domains in a Kubernetes configuration. The example above comes from a Minikube Cluster with three local search domains specified.

Pay attention to the ndots:5 option. It is important to understand, how both search and ndots settings work together.

To understand both concepts, refer to the resolv.conf(5) Linux man page

The search represent the search path for a particular domain. Interestingly dev.to or example.com are not FQDN (fully qualified domain name). A standard convention that most DNS resolvers follow is that if a domain ends with a dot (.) (representing the root zone), the Domain is FQDN. Some resolvers try to act smart and append the dot (.) themselves. So dev.to. is an FQDN, dev.to is not.

One important point from the resolv.conf(5) Linux man page For environments with multiple subdomains please read options ndots:n to avoid unnecessary traffic for the root-dns-servers. Note that this process may be slow and can generate a lot of network traffic if the servers for the listed domains are not local and that queries will time out if no server is available for one of the domains.

The ndots represents the threshold value of the number of dots in a query name to consider it a "fully qualified" domain name.

If ndots is five (5) (the default in Kubernetes), and the name contains less than five (5) dots inside it, the syscall will try to resolve it sequentially through all local search domains first and - in case none succeed - it will resolve as an absolute name only at last. For instance, the domain name www.example.com contains two dots (.), and the number of dots (.) is less than the value of ndots.

Therefore, when querying a domain name, the DNS query iterates through all search paths until the answer contains a NOERROR code.

www.example.com.<namespace>.svc.cluster.local
www.google.com.svc.cluster.local
www.google.cluster.local
www.google.com

It is important to remark that the DNS requests the A and AAAA records in parallel. The single-request option in /etc/resolv.conf has a default configuration to perform parallel IPv4 and IPv6 lookups. This option can be disabled using the configuration option single-request in the /etc/resolv.conf configuration file.



option single-request

Capturing Traffic in a Kubernetes Pod

There are different ways to capture traffic in a Kubernetes Pod. All the examples are based on the latest Kubernetes functionality using Ephemeral Debug Containers

First, let's create a tcpdump debug image. Wireshark will use it to display the attached pod traffic. The build process creates a multi-platform image to be able to run in linux/amd64 and linux/arm64

The Dockerfile



ARG build_for=linux/amd64,linux/arm64
FROM alpine:latest as base

LABEL maintainer="<yourusername>"

# Packages to build image requirements
RUN apk add --no-cache \
    tcpdump

ENTRYPOINT [ "tcpdump" ]
CMD [ "-i", "any" ]

The build command

To create a multi-platform image in dockerhub let's create a builder instance and use the extended build capabilities with BuildKit.



docker buildx create --name buildx --driver-opt network=host --use
docker buildx inspect --bootstrap
docker buildx build -t <yourusername>/tcpdump:v1.0.0 --platform linux/amd64 --platform linux/arm64 --file Dockerfile --push .
docker buildx imagetools inspect <yourusername>/tcpdump:v1.0.0
docker buildx rm buildx

The output shows both images with their platforms:



Name:      docker.io/<yourusername>/tcpdump:v1.0.0
MediaType: application/vnd.docker.distribution.manifest.list.v2+json
Digest:    sha256:9dd8cb1d4b77b7d02d41ff8418cd442c01badfe8ecd0c0a3a58f43f528eba378

Manifests:
  Name:      docker.io/<yourusername>/tcpdump:v1.0.0@sha256:0c341c671566dbc3cdded9da05120bb2216142f46516c14cf3d10b6c38997195
  MediaType: application/vnd.docker.distribution.manifest.v2+json
  Platform:  linux/amd64

  Name:      docker.io/<yourusername>/tcpdump:v1.0.0@sha256:c6de3ab95521c9e7e07a05d99935d19686b8d6e81ab85ce631312cffe57d2ce3
  MediaType: application/vnd.docker.distribution.manifest.v2+json
  Platform:  linux/arm64

Attaching an ephemeral container to the Nginx Pod

Now that the tcpdump image is ready, create an ephemeral container called debugger:



kubectl debug --image <yourusername>/tcpdump:v1.0.0 -c debugger $(kubectl get pod -l app=nginx -o name)

Connecting Wireshark to the ephemeral container

Once created, run Wireshark, and connect it to the just-created container.



kubectl exec -c debugger deployments/nginx -- tcpdump -s 0 -n -w - -U -i any | Wireshark -kni -

Request the URL from the POD

As in the local machine, do curl http://example.com in the Nginx Pod.



kubectl exec deployments/nginx -c nginx -- curl http://example.com

Analyzing the Traffic

As expected, there are eight (8) requests to the DNS (A and AAAA) with a negative No such name answer for every pair request until reaching the end of the search list and trying with example.com

Why `ndots:5`?

ndots:5 generates unnecessary DNS queries. So why five (5) is the default value?

Two comments in the Kubernetes code explain why ndots should be five (5) in Kubernetes:

The reason ndots is five (5) is to allow SRV record lookups to be relative to the cluster domain.

A typical SRV record has the form _service._protocol.name. and in Kubernetes, the name has the form service.namespace.svc. The formed record will look like _service._protocol.service.namespace.svc. This query contains four dots. If ndots is four (4), it would be considered an FQDN and will fail to resolve. With ndots to five (5), it won't be considered an FQDN and will be searched relative to cluster.local.

Testing the theory with `ndots` less than five (5).

Let's see in practice how ndots behaves with the DNS service, and how it breaks when is less than five (5).

Restart the nginx deployment to start from scratch:



kubectl rollout restart deployment nginx

Prepare a file to patch the current deployment with the new ndots configuration and apply.



---
spec:
  template:
    spec:
      dnsConfig:
        options:
          - name: ndots
            value: '4'



kubectl patch deployments.apps nginx --patch-file ndots-patch.yaml

Install nslookup in the pod for testing purposes



kubectl exec deployments/nginx -c nginx -- bash -c "apt-get update && apt-get install dnsutils -y"

Preparing the ephemeral container for ndots testing

Following the same procedure with Wireshark create the ephemeral container called debugger:



kubectl debug --image <yourusername>/tcpdump:v1.0.0 -c debugger $(kubectl get pod -l app=nginx -o name)

Connecting Wireshark for ndots testing

Once created, run Wireshark, and connect it to the just-created container.



kubectl exec -c debugger deployments/nginx -- tcpdump -s 0 -n -w - -U -i any | Wireshark -kni -

Resolve the DNS Service

Run nslookup _dns._udp.kube-dns.kube-system.svc in the Nginx Pod.



kubectl exec deployments/nginx -c nginx -- nslookup _dns._udp.kube-dns.kube-system.svc

In the console, the error is clear:



** server can't find _dns._udp.kube-dns.kube-system.svc: NXDOMAIN

Also in the Wireshark traffic:

The test with ndots:5 passes by changing the patch to"



---
spec:
  template:
    spec:
      dnsConfig:
        options:
          - name: ndots
            value: '5'

Apply the same way:



kubectl patch deployments.apps nginx --patch-file ndots-patch.yaml

Install nslookup in the pod for testing purposes



kubectl exec deployments/nginx -c nginx -- bash -c "apt-get update && apt-get install dnsutils -y"

and repeat the process:



kubectl exec deployments/nginx -c nginx -- nslookup _dns._udp.kube-dns.kube-system.svc

Create the ephemeral container called debugger:



kubectl debug --image <yourusername>/tcpdump:v1.0.0 -c debugger $(kubectl get pod -l app=nginx -o name)

Launch Wireshark:



kubectl exec -c debugger deployments/nginx -- tcpdump -s 0 -n -w - -U -i any | Wireshark -kni -

And run nslookup _dns._udp.kube-dns.kube-system.svc in the Nginx Pod.



kubectl exec deployments/nginx -c nginx -- nslookup _dns._udp.kube-dns.kube-system.svc

The console shows:



Name:   _dns._udp.kube-dns.kube-system.svc.cluster.local
Address: 10.96.0.10

And Wireshark loops properly over DNS search until reaching cluster.local

`ndots:5` can negatively affect performance

The default ndots configuration is perfect for default Kubernetes services, but it shouldn't be for later deployed microservices.

Cluster and applications, when connecting with other external components may suffer a negative performance impact and slowness. The DNS can become a bottleneck in case of heavy traffic.

Testing CoreDNS Performance with multiple requests

So far, we have a rich theory but no data. Observability needs both enough data and a theory within which that data can be refined.

Let's create the test inside the Kubernetes Cluster using a small pod. It will launch between 60 and 80 requests per minute. This request range is enough to avoid Cluster overloading and to test the ndots behavior.

Building the application

The python code used is:



#!/usr/bin/env python
# -*- coding: utf-8 -*-

import asyncio
import concurrent.futures
import logging
import sys
import os
import requests

logging.basicConfig(format="%(asctime)s %(levelname)s:%(name)s: %(message)s",
                    datefmt="%d-%b-%y %H:%M:%S", stream=sys.stdout, level=logging.INFO)

logger = logging.getLogger('httprequests')
logging.getLogger("chardet.charsetprober").disabled = True

benchuri = os.environ.get('BENCHURI', 'http://www.example.com')


async def main():

    with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:

        fetch = asyncio.get_event_loop()
        futures = [
            fetch.run_in_executor(
                executor,
                requests.get,
                benchuri
            )
            for i in range(20)
        ]
        for request in await asyncio.gather(*futures):
            logger.info(request)

if __name__ == '__main__':

    while True:
        loop = asyncio.get_event_loop()
        loop.run_until_complete(main())

And the Dockerfile:



ARG build_for=linux/amd64,linux/arm64
FROM python:alpine3.10 as base

LABEL maintainer="<yournamehere>"

RUN mkdir /app
COPY dnsrequest.py /app/dnsrequest.py
ADD requirements.txt requirements.txt

RUN pip install --upgrade pip
RUN pip install -r requirements.txt && chmod +x /app/dnsrequest.py && adduser -S none
USER none

WORKDIR /app

ENTRYPOINT ["python", "dnsrequest.py"]

The python file is called dnsrequest.py, and the requirements.txt contains one line:



requests

The process to build the Dockerfile is the same as explained with tcpdump above.



docker buildx create --name buildx --driver-opt network=host --use
docker buildx inspect --bootstrap
docker buildx build -t <yourusername>/dnsbench:v1.0.0 --platform linux/amd64 --platform linux/arm64 --file Dockerfile --push .
docker buildx imagetools inspect <yourusername>/dnsbench:v1.0.0
docker buildx rm buildx

Launching the Application

Minikube under Docker is enough to perform the test. To create the deployment run:



kubectl create deployment dnsbench --image <yourusername>/dnsbench:v1.0.0

Once launched, the CPU from CoreDNS will increase immediately with the default configuration. The DNS log shows all the work performed from a single request.

Note: To activate the CoreDNS Logs, edit the DNS configmap and add the word log in the coredns configuration:



[INFO] 10.244.0.7:33509 - 64525 "AAAA IN www.example.com.default.svc.cluster.local. udp 59 false 512" NXDOMAIN qr,aa,rd 152 0.000022583s
[INFO] 10.244.0.7:33509 - 64400 "A IN www.example.com.default.svc.cluster.local. udp 59 false 512" NXDOMAIN qr,aa,rd 152 0.00005575s
[INFO] 10.244.0.7:35864 - 8087 "AAAA IN www.example.com.svc.cluster.local. udp 51 false 512" NXDOMAIN qr,aa,rd 144 0.000044s
[INFO] 10.244.0.7:35864 - 8004 "A IN www.example.com.svc.cluster.local. udp 51 false 512" NXDOMAIN qr,aa,rd 144 0.000053792s
[INFO] 10.244.0.7:35569 - 21607 "AAAA IN www.example.com.cluster.local. udp 47 false 512" NXDOMAIN qr,aa,rd 140 0.00004025s
[INFO] 10.244.0.7:35569 - 21524 "A IN www.example.com.cluster.local. udp 47 false 512" NXDOMAIN qr,aa,rd 140 0.000065667s
[INFO] 10.244.0.7:53735 - 22419 "AAAA IN www.example.com. udp 33 false 512" NOERROR qr,aa,rd,ra 76 0.000035041s
[INFO] 10.244.0.7:53735 - 22335 "A IN www.example.com. udp 33 false 512" NOERROR qr,aa,rd,ra 64 0.000027542s

By changing the DNS ndots:5 option to ndots:1 with



---
spec:
  template:
    spec:
      dnsConfig:
        options:
          - name: ndots
            value: '1'



kubectl patch deployments.apps dnsbench --patch-file ndots-patch.yaml

Or changing the request URI from http://www.example.com to http://www.example.com. (Note the dot (.) at the end)

CPU decreases radically. CoreDNS Log shows:



[INFO] 10.244.0.11:54982 - 63488 "A IN www.example.com. udp 33 false 512" NOERROR qr,aa,rd,ra 64 0.000057167s
[INFO] 10.244.0.11:54982 - 63571 "AAAA IN www.example.com. udp 33 false 512" NOERROR qr,aa,rd,ra 76 0.000119333s

Find the CPU load in the CoreDNS CPU diagram below:

The application CPU doesn't change, and the requests have the same frequency:

Regarding network traffic in the CoreDNS, there is also exhaustion when ndots:5:

And in the application:

Conclusion

Use specific ndots for your application under spec - dnsConfig. Remember that ndots:1 ignores the search list because the query name satisfies the ndots threshold (At least one dot).

The aggressive ndots:1 forces to use the full domain for every intra-node communication. Using fully qualified names can be described as a "workaround" in different resources. I see it as a proper implementation.

When the application has many DNS requests, ndots:2 increases DNS performance and latency.

Creating a blockchain in 60 lines of Python

Jose Angel Munoz — Fri, 05 Nov 2021 23:27:12 +0000

When I read the document written by Phu Minh, I was curious about learning different concepts about blockchain. Once I started to read the code, I wanted to match it with Python to understand also the differences with JavaScript.

The objective of this post is finding the differences in both languages and serve as the Python appendix of the original post.

Even though the original document comes from a Python example, I wanted to have an exact match with the JavaScript code to compare.

Let's also fit the python code in the promised 60 lines.

Blockchain

Although the idea is to mimic the entire post and use the same sections to follow the code,

For the Blockchain definition, I prefer the following:

Blockchain is a system of recording information in a way that makes it difficult or impossible to change, hack, or cheat.

Setup

We are using Python for this project, so be sure to install it if you haven't.

As I have said, a block is just an object that has some information on it, so we should have a Block class like this:

class Block:

    def __init__(self, timestamp=None, data=None):
        self.timestamp = timestamp or time()
        # this.data should contain information like transactions.
        self.data = [] if data is None else data

The class definition is quite similar in both languages. In Python, we use self instead of this and init is a constructor method.

Comments are also similar in both languages. In Python, we use # to comment vs. // in javascript.

Fot the sha256 algorithn, I will use the hashlib library vs the crypto package in javascript.

from hashlib import sha256

class Block:

    def __init__(self, timestamp=None, data=None):
        self.timestamp = timestamp or time()
        self.data = [] if data is None else data
        self.hash = self.getHash()
        self.prevHash = None # previous block's hash

    def getHash(self):
        hash = sha256()
        hash.update(str(self.prevHash).encode('utf-8'))
        hash.update(str(self.timestamp).encode('utf-8'))
        hash.update(str(self.data).encode('utf-8'))
        return hash.hexdigest()

In the getHash method, from an empty hash, we update it with the rest of components. The hash is the result of the concatenation of the previous hash, the timestamp and the data. All of then with the .encode('utf-8') to convert the string to bytes.

The blockchain

Let's move over to the blockchain class.

class Blockchain:
    def __init__(self):
        # This property will contain all the blocks.
        self.chain = []

Again, the class definition is similar in both languages.

To create the genesis block, we just call the Block with the current timestamp using time. To do that, we need to import the time library.

The string conversion is done with str instead of toString.

from time import time

class Blockchain:
    def __init__(self):
        # Create our genesis block
        self.chain = [Block(str(int(time())))]

And the method to get the latest block is similar. We use len to get the length of the chain instead of length in javascript.

    def getLastBlock(self):
        return self.chain[len(self.chain) - 1]

To add the block to the blockchain, we just call the addBlock method. The code is almost the same except the append (push in javascript).

def addBlock(self, block):
        # Since we are adding a new block, prevHash will be the hash of the old latest block
        block.prevHash = self.getLastBlock().hash
        # Since now prevHash has a value, we must reset the block's hash
        block.hash = block.getHash()
        self.chain.append(block)

Validation

In the validation method, we start using range as a big difference. Also, because we don't use constants in Python, we just use normal variables.

For the conditional, python uses or instead of || in javascript.

def isValid(self):
    # Iterate over the chain, we need to set i to 1 because there are nothing before the genesis block, so we start at the second block.
    for i in range(1, len(self.chain)):
        currentBlock = self.chain[i]
        prevBlock = self.chain[i - 1]

        # Check validation
        if (currentBlock.hash != currentBlock.getHash() or prevBlock hash != currentBlock.prevHash):
            return False

    return True

Proof-of-work

We can implement this system by adding a mine method and a nonce property to our block. Be careful because nonce must be declared before calling the self.getHash() method. If not, you will get the error AttributeError: 'Block' object has no attribute 'nonce'.

class Block:

    def __init__(self, timestamp=None, data=None):
        self.timestamp = timestamp or time()
        self.data = [] if data is None else data
        self.prevHash = None # previous block's hash
        self.nonce = 0
        self.hash = self.getHash()

    # Our hash function.
    def getHash(self):

        hash = sha256()
        hash.update(str(self.prevHash).encode('utf-8'))
        hash.update(str(self.timestamp).encode('utf-8'))
        hash.update(str(self.data).encode('utf-8'))
        hash.update(str(self.nonce).encode('utf-8'))
        return hash.hexdigest()

    def mine(self, difficulty):
        # Basically, it loops until our hash starts with
        # the string 0...000 with length of <difficulty>.
        while self.hash[:difficulty] != '0' * difficulty:
            # We increases our nonce so that we can get a whole different hash.
            self.nonce += 1
            # Update our new hash with the new nonce value.
            self.hash = self.getHash()

To create the difficulty property:

self.difficulty = 1

And the addBlock method:

    def addBlock(self, block):
        block.prevHash = self.getLastBlock().hash
        block.hash = block.getHash()
        block.mine(self.difficulty)
        self.chain.append(block)

Testing out the chain

First, import the module and use the Blockchain class the same way using JeChain object:

from blockchain import Block
from blockchain import Blockchain
from time import time

JeChain = Blockchain()

# Add a new block
JeChain.addBlock(Block(str(int(time())), ({"from": "John", "to": "Bob", "amount": 100})))
# (This is just a fun example, real cryptocurrencies often have some more steps to implement).

# Prints out the updated chain
print(JeChain)

It should looks like this:

[
    {
        "data": [],
        "timestamp": "1636153236",
        "nonce": 0,
        "hash": "4caa5f684eb3871cb0eea217a6d043896b3775f047e699d92bd29d0285541678",
        "prevHash": null
    },
    {
        "data": {
            "from": "John",
            "to": "Bob",
            "amount": 100
        },
        "timestamp": "1636153236",
        "nonce": 14,
        "hash": "038f82c6e6605acfcad4ade04e454eaa1cfa3d17f8c2980f1ee474eefb9613e9",
        "prevHash": "4caa5f684eb3871cb0eea217a6d043896b3775f047e699d92bd29d0285541678"
    }
]

but only after adding the __repr__ method to the Blockchain class:

import json

    def __repr__(self):
        return json.dumps([{'data': item.data, 'timestamp': item.timestamp, 'nonce': item.nonce, 'hash': item.hash, 'prevHash': item.prevHash} for item in self.chain], indent=4)

Updated bonus: Difficulty and block time

For the blockTime just:

self.blockTime = 30000

Have a look to the ternary used for the difficulty system. In Python, the ternary operator is (if_test_is_false, if_test_is_true)[test], resulting in:

    def addBlock(self, block):
        block.prevHash = self.getLastBlock().hash
        block.hash = block.getHash()
        block.mine(self.difficulty)
        self.chain.append(block)

        self.difficulty += (-1, 1)[int(time()) - int(self.getLastBlock().timestamp) < self.blockTime]

The final python code (Without proper formatting) in 60 lines is:

# -*- coding: utf-8 -*-

from hashlib import sha256
import json
from time import time


class Block:

    def __init__(self, timestamp=None, data=None):
        self.timestamp = timestamp or time()
        self.data = [] if data is None else data
        self.prevHash = None
        self.nonce = 0
        self.hash = self.getHash()

    def getHash(self):

        hash = sha256()
        hash.update(str(self.prevHash).encode('utf-8'))
        hash.update(str(self.timestamp).encode('utf-8'))
        hash.update(str(self.data).encode('utf-8'))
        hash.update(str(self.nonce).encode('utf-8'))
        return hash.hexdigest()

    def mine(self, difficulty):
        while self.hash[:difficulty] != '0' * difficulty:
            self.nonce += 1
            self.hash = self.getHash()

class Blockchain:

    def __init__(self):
        self.chain = [Block(str(int(time())))]
        self.difficulty = 1
        self.blockTime = 30000

    def getLastBlock(self):
        return self.chain[len(self.chain) - 1]

    def addBlock(self, block):
        block.prevHash = self.getLastBlock().hash
        block.hash = block.getHash()
        block.mine(self.difficulty)
        self.chain.append(block)

        self.difficulty += (-1, 1)[int(time()) - int(self.getLastBlock().timestamp) < self.blockTime]

    def isValid(self):
        for i in range(1, len(self.chain)):
            currentBlock = self.chain[i]
            prevBlock = self.chain[i - 1]

            if (currentBlock.hash != currentBlock.getHash() or prevBlock.hash != currentBlock.prevHash):
                return False

        return True

    def __repr__(self):
        return json.dumps([{'data': item.data, 'timestamp': item.timestamp, 'nonce': item.nonce, 'hash': item.hash, 'prevHash': item.prevHash} for item in self.chain], indent=4)

Hopefully you will enjoy and learn with both posts!

imjoseangel, and I support women devs in 2021 and beyond!

Jose Angel Munoz — Sun, 07 Mar 2021 20:18:58 +0000

As an ally, I will call out gender bias and inequity by inspiring innovation, creativity, acknowledgment and support from women AND men.

We need to make our DEV community more inclusive supporting women leaders.

Let's strive, together to explain that the standard environments are those where we RESPECT, CODE, ACCEPT, CREATE, HAVE FUN and WORK, TOGETHER.

From 100% to 0% CPU with memoization

Jose Angel Munoz — Sun, 06 Dec 2020 10:43:12 +0000

I have followed the 30 first minutes of the freecodecamp training named Dynamic Programing for Beginners – How to Solve Coding Challenges with Memoization and Tabulation.

The first part is about programming efficiency and timing but also about infrastructure resources.

The training shows Javascript examples, but I moved to Python ♥️

The code:

def fib(n):
    if n == 0:
        return 0
    if n == 1:
        return 1
    return fib(n - 1) + fib(n - 2)

print('The first 50 fibonacci numbers are:')
print(','.join([str(fib(n)) for n in range(50)]))

It takes too many CPU resources and it doesn't even finish:

Moving to:

def fib(n, memo={}):
    if n in memo:
        return memo[n]

    if n == 0:
        return 0

    if (n <= 2):
        return 1

    memo[n] = fib(n - 1, memo) + fib(n - 2, memo)
    return memo[n]

print('The first 50 fibonacci numbers are:')
print(','.join([str(fib(n)) for n in range(50)]))

Takes less than a second to run and almost no CPU resorces:

real    0m0.156s
user    0m0.075s
sys     0m0.059s

The Urinal Algorithm. How I improved my Python and Go skills with this funny Algorithm

Jose Angel Munoz — Wed, 23 Sep 2020 14:24:50 +0000

The first time I read about the Urinal Algorithm was in a Reddit post. In fact, the author called it the Men Restroom Algorithm so I named my Urinal Based Algorithm as MenRestRoom. I started to develop my own algorithm based on that post and although it is unfinished, I use it to improve my programming skills.

At the time of writing this article, I realized that the Algorithm with its original name, had some post in StackOverflow even with an Unisex implementation with Priority. It also has a cool document from 2010 called the Urinal Problem which I promise I will review in the future to find ideas to improve mine.

The Algorithm

The concept is simple: It is a well-researched fact that men in a restroom generally prefer to maximize their distance from already occupied stalls, by occupying the middle of the longest sequence of unoccupied places. For example, consider the situation where ten stalls are empty.

The first visitor will occupy a middle position:

🚽 🚽 🚽 🚽 🚶 🚽 🚽 🚽 🚽 🚽 🚪

In my variant, there is a door, so the left side is clearly the farther stalls from the door. Also I have improved it with emojis. Cool, isn't it?.

The next visitor will use the middle or the farther stall from empty area at the left. Always keeping at least one stall empty between visitors.

🚶 🚽 🚽 🚽 🚶 🚽 🚽 🚽 🚽 🚽 🚪

🚽 🚽 🚶 🚽 🚶 🚽 🚽 🚽 🚽 🚽 🚪

The initial sequence can be like:

🚽 🚽 🚽 🚽 🚶 🚽 🚽 🚽 🚽 🚽 🚪

🚶 🚽 🚽 🚽 🚶 🚽 🚽 🚽 🚽 🚽 🚪

🚶 🚽 🚶 🚽 🚶 🚽 🚽 🚽 🚽 🚽 🚪

🚶 🚽 🚶 🚽 🚶 🚽 🚽 🚽 🚶 🚽 🚪

🚶 🚽 🚶 🚽 🚶 🚽 🚶 🚽 🚶 🚽 🚪

Once every other stall is occupied, we can randomly use the rest of the stalls until finish:

🚶 🚽 🚶 🚽 🚶 🚽 🚶 🚶 🚶 🚽 🚪

🚶 🚶 🚶 🚽 🚶 🚽 🚶 🚶 🚶 🚽 🚪

🚶 🚶 🚶 🚽 🚶 🚶 🚶 🚶 🚶 🚽 🚪

🚶 🚶 🚶 🚽 🚶 🚶 🚶 🚶 🚶 🚶 🚪

🚶 🚶 🚶 🚶 🚶 🚶 🚶 🚶 🚶 🚶 🚪

More Fun added

Well, this is how the stalls become occupied but in real life visitors use them for a limited time. Also, the time of peeing is different from visitor to visitor. In the other hand, we assume that the time to take a stall is fixed (By default 2 seconds). The code needs to manage both take and leave functionality at the same time.

As said, the code needs to be improved. When some consecutive stalls gets empty, the algorithm continues to use a random value instead of maximizing the distance. I promise I will work on this option in the future.

Note: I will work on adding some code tests for Python too. I have added some interesting ones for the Golang functions.

Implementation

I'm going to explain What and How I learned implementing this algorithm in Python and how I used it to learn some Golang techniques.

Variables

Python and Golang have different variable scopes (Local and Global) but the way to define and use them is harder in Golang. Constant and variables types need to be properly defined and due to the fact that it is a statically typed language, their variables cannot be changed at runtime as with Python.

Additionally, Go is not a pure object oriented programming language. The way to manage functions and how to call them, changes significantly if you are used to program in Python.

Let's define our constants and variables:

Constants

Description	Constant	Type
Maximum time a visitor is occupying a stall	maxtimepeeing	Int
Minimum time a visitor is occupying a stall	mintimepeeing	Int
Number of stalls	stalls	Int
Emoji for door	emoDoor	string
Emoji for empty stall	emoEmpty	string
Emoji for taken stall	emoTaken	string
Stall occupancy frequency	stallfreq	time.Duration

Vars

Description	Variable	Type
Untaken stalls	untaken	List of integers
Taken stalls	taken	List of integers
time a visitor is occupying a stall	timePeeing	time.Duration
Stall occupied on every iteration	stall	Int
Left side of the stalls	left	List of integers
Right side of the stalls	right	List of integers
Shows stall status on Screen	stallPrint	List of strings

The code explained

Generate a list of integers

First of all, we need to initialize all our variables with the startup values. We need a list of n untaken stalls.

Python:



untaken = list(range(0, stalls))

If stalls = 4, it creates the list: [1, 2, 3, 4]

Go:

In go, there is no a built-in range function, so we need to create it first:



type Range struct {
    MinList int
    MaxList int
}

// RangeArray ...
// Created this way to use struct with a function inside a module
func (arrayrange Range) RangeArray() []int {

    result := make([]int, arrayrange.MaxList-arrayrange.MinList+1)
    for Item := range result {
        result[Item] = arrayrange.MinList + Item
    }

    return result
}

untaken = functions.Range{
    MinList: 1,
    MaxList: stalls,
}.RangeArray()

I created this way to learn about structs and Object Oriented Programming (OOP) within Go.

Generate a random number from a given range

Let's go with the timepeeing var. This var will be created at init time (Another important topic that we will review later) and reset with a new value when calling the leaveStall function. It contains a random integer between mintimepeeing and maxtimepeeing.

Python:



timepeeing = random.randint(mintimepeeing, maxtimepeeing)

Golang:

To generate a random value between two values in go, use this:



rand.Seed(time.Now().UnixNano())
timePeeing = time.Duration(rand.Intn(maxtimepeeing-mintimepeeing+1) + mintimepeeing)

Calculate the stall to be taken on every iteration

In the first iteration, the taken stall is the one in the middle of the untaken row. It is calculated with the sum of the integers of the array and divided by its length. The result is rounded to ceil.

Python:



new_stall = round(sum(untaken) / len(untaken) + .5)

Golang:

There is no built-in implementation for the sum of the items of a list. I had to implement too.



// Array ...
type Array []int

// SumArray ...
// Created this way to use struct with a function inside a module
func (array Array) SumArray() int {
    result := 0
    for _, numb := range array {
        result += numb
    }
    return result
}

newStall = int(math.Ceil(float64(functions.Array(untaken).SumArray()) / float64(len(untaken))))

And again, I created this way to learn about OOP within Go. Cool, isn't it?

The Left and Right arrays with alternative stalls

The idea is divide the stalls in two (Left and Right) given the already occupied newStall. Having this untaken list:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

If newStall is 5 in this scenario, the left list is [0, 1, 2, 3, 4] and the right list [6, 7, 8, 9]. Integers 4 and 6 are next to newStall and must be empty. Following the same rule, we will build a list of potential stalls to be taken:

For the left side:

[1, 3]

For the right side:

[7, 9]

Let's do it. In Python, is quite easy:

Python:



left = untaken[1:new_stall:2]
right = untaken[new_stall + 2::2]

Again, in golang I had to create a new function:

Golang:



// SliceArray ...
func SliceArray(array []int, start int) []int {

    result := []int{}
    for i := start; i < len(array); i += 2 {
        result = append(result, array[i])
    }
    return result
}

if stalls%2 == 0 {
    left = functions.SliceArray(untaken[0:newStall-1], 1)
} else {
    left = functions.SliceArray(untaken[0:newStall-1], 0)
}
right = functions.SliceArray(untaken[newStall:], 1)

With this function, we need to check if the stalls integer is even or odd to create the left list from untaken list. The start integer changes depending on the length of the list, something I need to improve in future releases.

Printing on screen

This is the easier one for the first stage. We need to prepare the empty stalls with the door and show it on screen:

Python:



stall_print = list(emo_empty * stalls + emo_door)

Golang:



stallPrint = strings.SplitN(strings.Repeat(emoEmpty, stalls)+emoDoor, "", stalls+1)

Init Functions and Methods

Before carry on with the main logic, I think it is interesting to refer about the way Python and Golang manage the Init functions.

The __init__ in Python is one of the main pieces when talking about OOP. This method initializes the object state. It contains the values and instructions executed at the time of the Object Creation.

The init() function in Golang are defined in the package block. It contains the values and instructions executed at the time of the Package call although it runs only once even if the package is imported many times.

Variable name convention

I think it is also nice to realize that the name convention changes among programming languages. I recommend to search for the different naming conventions for Python and Golang on the Internet.

For instance:

stall_print for Python
stallPrint for Go

The Take Stall logic

As explained in the section, we need to move items between the untaken and taken lists and vice versa.

When the process starts, it puts the middle of the stalls in the taken and paints the new scenario. After that, it checks if the left list has elements to use them. Then the right list and finally the ones unoccupied.

The code:

Python:



        if untaken:
            if not taken:
                new_stall = new_stall
            else:
                if left:
                    new_stall = random.choice(left)
                    left.remove(new_stall)
                elif right:
                    new_stall = random.choice(right)
                    right.remove(new_stall)
                else:
                    new_stall = random.choice(untaken)

            untaken.remove(new_stall)
            taken.append(new_stall)

Golang:

To get the position of the stall, I created the IndexArray function, also take a look to the append built-in function. The documentation of the built-in package describes append.

func append(s []T, vs ...T) []T



// IndexArray ...
func IndexArray(array []int, item int) int {
    for result := range array {
        if array[result] == item {
            return result
        }
    }
    return -1
}

if len(untaken) > 0 {
    if len(taken) == 0 {
        stall = newStall
    } else {
        if len(left) > 0 {
            randomIndex := rand.Intn(len(left))
            stall = left[randomIndex]
            left = append(left[:randomIndex], left[randomIndex+1:]...)
        } else if len(right) > 0 {
            randomIndex := rand.Intn(len(right))
            stall = right[randomIndex]
            right = append(right[:randomIndex], right[randomIndex+1:]...)

        } else {
            randomIndex := rand.Intn(len(untaken))
            stall = untaken[randomIndex]
        }
    }
    stallIndex := functions.IndexArray(untaken, stall)
    untaken = append(untaken[:stallIndex], untaken[stallIndex+1:]...)
}
taken = append(taken, stall)

Create the stall for printing

To print the output on screen, we need to update the stallPrint list:

Python:

In Python, we need two steps, one to remove, one to insert.



stall_print.pop(taken[-1])
stall_print.insert(taken[-1], emo_taken)

Golang:

In Go can be done just replacing:



stallPrint[taken[len(taken)-1]-1] = emoTaken

The Leave Stall logic

A visitor can leave the stall, only when it is taken and following the arrive order (For now).

Python:



if taken:
    old_stall = taken[0]
    taken.remove(old_stall)
    untaken.append(old_stall)

Golang:



oldStall := taken[0]
taken = append(taken[:0], taken[1:]...)
untaken = append(untaken, oldStall)

The stall_print does not change, we just need to leave it empty:

Python:



stall_print.pop(old_stall)
stall_print.insert(old_stall, emo_empty)

Golang:



stallPrint[oldStall-1] = emoEmpty

And the timepeeing is recalculated:

Python:



timepeeing = random.randint(mintimepeeing, maxtimepeeing)

Golang:



rand.Seed(time.Now().UnixNano())
timePeeing = time.Duration(rand.Intn(maxtimepeeing-mintimepeeing+1) + mintimepeeing)

As discussed, in future revisions we can order the untaken list and recalculate left and right with a more complex approach. For now, this is fine to learn.

The final touch. Timers

Probably the part that took me more time to put in place. To me, it was important to manage both take and leave options independently with specific times. I was thinking in Threading for Python but it changes the way it is managed in Go. Let's do it.

Python:

As simple as using the Threading Module and:



threading.Timer(timepeeing, leave_stall).start()

Where timepeeing is the time and leave_stall() the function.

Golang:

It took me some time to understand tickers but finally I got it working. Once you get it, the logic it quite simple. Note the Reset timer option.



takeTicker := time.NewTicker(stallFreq * time.Second)
leaveTicker := time.NewTicker(timePeeing * time.Second)

select {
case <-takeTicker.C:
    takeStall()
case <-leaveTicker.C:
    leaveStall()
    leaveTicker.Reset(timePeeing * time.Second)
}

Orchestrating the solution

The program starts with the untaken list totally full, so we need to run the solution until the list becomes totally empty:

Python:

After creating the newpee object, we check the untaken variable:



while newpee.untaken:

To print the result:



for item in newpee.stall_print:
    print(item, end=' ', flush=True)

Golang:

The golang Tour says: For is Go's "while". Then:



for len(untaken) > 0 {
    }

To print:



for _, item := range stallPrint {
    fmt.Print(item + " ")

Final words

I'm sure that the algorithm can be improved in functionality, efficiency and style but the idea is to focus in learning and having a small challenge to learn a new language.

Don't forget to implement good practices and create unit tests for your libraries and functions. This is my first approach for golang just to understand how testing is implemented:



package functions

import (
    "reflect"
    "testing"
)

var mylist = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

func TestRangeArray(t *testing.T) {
    expected := mylist
    newarray := Range{
        MinList: 1,
        MaxList: 10,
    }
    ret := newarray.RangeArray()

    if !reflect.DeepEqual(ret, expected) {
        t.Errorf("RangeArray() = %q, want %q", ret, expected)
    }
}

func TestSumArray(t *testing.T) {
    expected := 55
    newarray := Array(mylist)
    if ret := newarray.SumArray(); ret != expected {
        t.Errorf("SumArray() = %q, want %q", ret, expected)
    }
}

func TestSliceArray(t *testing.T) {
    expectede := []int{2, 4, 6, 8, 10}
    rete := SliceArray(mylist, 1)
    expectedo := []int{1, 3, 5, 7, 9}
    reto := SliceArray(mylist, 0)

    if !reflect.DeepEqual(rete, expectede) {
        t.Errorf("SliceArray() = %q, want %q", rete, expectede)
    }

    if !reflect.DeepEqual(reto, expectedo) {
        t.Errorf("SliceArray() = %q, want %q", reto, expectedo)
    }
}

func TestIndexArray(t *testing.T) {
    expected := 5

    if ret := IndexArray(mylist, 6); ret != expected {
        t.Errorf("SumArray() = %q, want %q", ret, expected)
    }
}

You can find the code here and here.

Thanks for reading and keep improving!

Release and Deploy Ansible Collection with GitHub Actions

Jose Angel Munoz — Sun, 09 Aug 2020 19:20:50 +0000

Prepare your repository

Follow the Ansible Developer Guide to prepare your content. The published collection can contain plugins, roles and playbooks (TBD) among others. Please check the oficial documentation regularly to keep your collection up to date.

Create your Ansible Galaxy account

Go to Ansible Galaxy and connect with your GitHub account. In order to publish content automatically to your account, you have to get and copy your personal API key.

Click over your username.
Preferences.
API Key. Show API Key.

Tip: For debugging and development purposes, there is a Development Environment of Ansible Galaxy available.

Adding the API Key to GitHub

On GitHub, navigate to the main page of the repository.
Under your repository name, click Settings.
In the left sidebar, click Secrets.
Type a name for your secret in the Name input box. We will use GALAXY_API_KEY for production and GALAXYDEV_API_KEY for development.

Find the full procedure in the GitHub Documentation.

Generate your `galaxy.yml` file

The process will read and use the file galaxy.yml not only to build the package with the ansible-galaxy command, also to create the tag and the release on GitHub. Be sure that the version in the file is correct and has not been used before.

At the time of writting, the process doesn't support tag replacement on GitHub or overwrite the version on Galaxy. Although the replace_old_tag flag will be available soon for GitHub I recommend to keep control of the releases process. I also recommend the use of the development environment for the first steps.

Example galaxy.yml:



---
namespace: "imjoseangel"
name: "common"
version: "0.1.4"
readme: "README.md"
authors:
    - "Jose Angel Munoz <josea.munoz@gmail.com>"
license:
    - "MIT"
tags:
    - imjoseangel
    - common
    - collection
    - linux
    - windows
    - util
repository: "https://www.github.com/imjoseangel/ansiblecommon"

In this example we will create the release 0.1.4 whether in GitHub and Ansible Galaxy.

Create the GitHub workflow

Create the following structure in your project:



.github/
└── workflows
    └── release.yml

The release.yml contains the actions for GitHub. In our example, we are going to use the action on-demand, using the workflow_dispatch option. So the header is:



---
name: Release and Deploy collection
on: # yamllint disable-line rule:truthy
  workflow_dispatch:

We are going to use only one job. The release and the deploy will use exactly the same build and we will avoid different builds for release and deploy.



jobs:
  releaseanddeploy:
    runs-on: ubuntu-latest
    if: github.repository == 'imjoseangel/ansiblecommon'
    strategy:
      matrix:
        python-version: [3.8]

Steps

First download the branch and read the version from the galaxy.yml file:



    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Get current version
        id: cversion
        run: echo "::set-output name=version::$(grep version galaxy.yml | awk -F'"' '{ print $2 }')"

Use the python version defined in the matrix and install ansible. Install also the requirements.txt if found. This step is not needed but I think it was cool to keep 😜 as reference.



      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v2
        with:
          python-version: ${{ matrix.python-version }}

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install --upgrade ansible
          if [ -f requirements.txt ]; then pip install -r requirements.txt; fi

Create a build directory with the content that will be included in the collection. Note that if you want to add extra files or directories, you need to add those to the files or directories variables.



      - name: Copy files and directories to source
        run: |
          mkdir -p build/src
          cp $files build/src
          cp -rf $directories build/src
        env:
          files: "README.md LICENSE ansible.cfg galaxy.yml"
          directories: "inventories playbooks roles vars"

Time to build the collection.



      - name: Build Ansible Collection
        run: ansible-galaxy collection build build/src --force

The next two steps will do the following:

Creates the release and tag with the version in the galaxy.yml file.
Adds the instructions to the release.
Attachs the collection to the release, keeping the source code (The whole project) and the collection package.



      - name: Create Release
        id: create_release
        uses: actions/create-release@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          tag_name: v${{ steps.cversion.outputs.version }}
          release_name: Release v${{ steps.cversion.outputs.version }}
          body: |
            # Ansible Collection: imjoseangel.common
            ![ReleaseBuildCollection](https://github.com/imjoseangel/ansiblecommon/workflows/ReleaseBuildCollection/badge.svg)

            Install with:
            ansible-galaxy collection install -r requirements.yml -f

            The requirements.yml needs to have the following format and content:
            ---
            collections:
                - https://github.com/imjoseangel/ansiblecommon/releases/download/v${{ steps.cversion.outputs.version }}/imjoseangel-common-${{ steps.cversion.outputs.version }}.tar.gz
          draft: false
          prerelease: false

      - name: Upload Release Asset
        id: upload-release-asset
        uses: actions/upload-release-asset@v1
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        with:
          upload_url: ${{ steps.create_release.outputs.upload_url }}
          asset_path: imjoseangel-common-${{ steps.cversion.outputs.version }}.tar.gz
          asset_name: imjoseangel-common-${{ steps.cversion.outputs.version }}.tar.gz
          asset_content_type: application/tar+gzip

Finally deploy the package to Ansible Galaxy.



      - name: Deploy Ansible collection to Galaxy
        run: ansible-galaxy collection publish imjoseangel-common-${{ steps.cversion.outputs.version }}.tar.gz --api-key ${{ secrets.GALAXY_API_KEY }}

If we want to use the development environment, the run: line has to be:



run: ansible-galaxy collection publish imjoseangel-common-${{ steps.cversion.outputs.version }}.tar.gz --server https://galaxy-dev.ansible.com/ --api-key ${{ secrets.GALAXYDEV_API_KEY }}

Where to find the release

On GitHub, under your project releases:

In the example: https://github.com/imjoseangel/ansiblecommon/releases

On Ansible Galaxy, under My Content

How to install the collection

The easiest way to install the collection is copying the ansible-galaxy command from the Ansible Galaxy project:

ansible-galaxy collection install imjoseangel.common

For internal projects, the best way is creating a requirements.yml file and follow the instructions in the release document:



---
collections:
    - https://github.com/imjoseangel/ansiblecommon/releases/download/v0.1.4/imjoseangel-common-0.1.4.tar.gz

Install it with:



ansible-galaxy collection install -r requirements.yml -f

If you want to improve this process or understand it better, you can visit the original project on GitHub

Forem: Jose Angel Munoz

AI Agents for Engineers — Part I

The Prompt

DAGS vs Workflows vs Agents

Reactions, Reflections, and Other Cheesy Words

Memory

Semantic Memory

Episodic Memory

Procedural Memory

Tools

Multiple Models

And Frameworks

Conclusion

We need more women

The Female Factor

Kubernetes Pods Stuck in Terminating: A Resolution Guide

Pod Termination

Why a Pod can hang on Terminating state

Finalizers

The PreStop hook and terminationGracePeriodSeconds

Remove Finalizers

Force Delete the POD

Extra: Finalizers blocking Kubernetes upgrade

Conclusion

What are your git aliases?

Introduction

My Gitconfig

The Path to Creative Deployments

Introduction - Fail Fast and Teams

Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. - Samuel Beckett

From Human Intervention to Full Automation

The first stage - Fear of losing a job

The second stage - Starting the Dunning-Kruger Effect

Using a CI/CD Tool with inline code

The third stage - Questioning our existing implementation

The fourth stage - Realizing there is still a long way to go

The fifth stage - The Grown-Up Mountain

The sixth stage - Plateau of Productivity

Summary

Tune up your Kubernetes Application Performance with a small DNS Configuration

Introduction

What is DNS?

How to debug DNS network traffic - Wireshark

What happens when calling a web page?

Creating the Wireshark Flow Graph

Preparing the filter

Capturing traffic

Request the URL in the Local Client

Understanding the captured traffic

The 3-Way Handshaking (SYN-ACK)

The Request and Connection Close (FIN ACK)

DNS on Kubernetes

Capturing Traffic in a Kubernetes Pod

The Dockerfile

The build command

Attaching an ephemeral container to the Nginx Pod

Connecting Wireshark to the ephemeral container

Request the URL from the POD

Analyzing the Traffic

Why ndots:5?

Testing the theory with ndots less than five (5).

Preparing the ephemeral container for ndots testing

Connecting Wireshark for ndots testing

Resolve the DNS Service

ndots:5 can negatively affect performance

Testing CoreDNS Performance with multiple requests

Building the application

Launching the Application

Conclusion

Creating a blockchain in 60 lines of Python

Blockchain

Setup

The blockchain

Validation

Proof-of-work

Testing out the chain

Updated bonus: Difficulty and block time

imjoseangel, and I support women devs in 2021 and beyond!

From 100% to 0% CPU with memoization

The Urinal Algorithm. How I improved my Python and Go skills with this funny Algorithm

Why a Pod can hang on `Terminating` state

Why `ndots:5`?

Testing the theory with `ndots` less than five (5).

`ndots:5` can negatively affect performance

Generate your `galaxy.yml` file