Forem: Jorge Alberto Díaz Orozco (Akiel)

Downloading Docker images where DockerHub won't work

Jorge Alberto Díaz Orozco (Akiel) — Sun, 04 Jan 2026 19:48:44 +0000

Why would you want to do this?

Back in 2016 I really wanted to start learning Docker. By the time It had already become a must-have in every developer toolbox. The promises were impressive and as a Linux nerd I was loving what I was reading about it. The problem: I was living in Cuba.

Cuba, among other countries, is actively blocked from downloading Docker images due to export restrictions. You can't even download what comes for free everywhere.

Not having access to a VPS or VPN that could mask my location at the time, my only alternative was relying on images downloaded by friends and saved using docker save, importing them in my docker environment using docker load.

Eventually my position in life shifted and I no longer live in Cuba but many developers just like me still struggle to get access to resources many of you in the other side of the world give for granted. Because of that, I decided to do my part to help my fellow Cuban developers.

So how do I use this?

Directly from the website

An instance of my service is deployed at https://dockerimagesave.akiel.dev/

Write the name and tag of the image you want to download and hit the Download button. A file will be eventually downloaded that you can import to your local Docker with docker load -i myimage_tag.tar.gz and you can share with your friends and colleagues.

The nerd way

Do you want to automate your way in? No problems, just use wget/curl/whatever rocks your terminal.
Here's an example using wget to download and load the ubuntu:25.04 image in which I included some retries "just in case":

wget -c --tries=5 --waitretry=3 --content-disposition "https://dockerimagesave.akiel.dev/image?name=ubuntu:25.04" && docker load -i ubuntu_25_04.tar.gz

Feel free o script around.

I want to help others

Great to hear! I'm only one person with limited resources. Setting up a server so your friends can use it is very simple. Just go to https://github.com/jadolg/DockerImageSave and follow the instructions to deploy using docker compose.

Wanna make the service better? PRs are open and I'm waiting for your code. Please make sure you write tests for the new code and also that it passes the already existing ones.

Another good idea to help is to participate in politics. This service fixes a problem that should not exist. It's completely artificial and fabricated by people trying to make other people's life harder. I would love to discontinue this service someday because the world is better.

A bit of unimportant history

The service itself is somewhat old. I wrote the first version around 6-7 years ago and just last week decided it was time for V2. You might find traces of V1 still in the wild. A much harder to use service that required a client application. That version is no longer maintained nor deployed anywhere as far as I know.

Final words

If you made it this far, thanks for reading. That already tells me you care about building things and about making technology accessible to the people who want to learn and use it.

This project started as a very personal workaround for a very real limitation. Revisiting it years later reminded me that small tools can still make a difference. Sometimes all it takes is removing one unnecessary barrier so someone can experiment, learn, or move forward with their work.

You do not need to use this service yourself to see its value. If it helps a friend, a colleague, or someone you have never met get unstuck, then it has done its job. If it motivates you to self host it, improve it, or build something similar, even better.

I sincerely hope we reach a point where tools like this are no longer needed because access is no longer restricted by geography or politics. Until then, I am happy to keep this running and to share it with anyone who finds it useful.

Thanks for reading, and happy hacking.

Keep Porkbun DNS Records Updated Automatically with Your Current IP

Jorge Alberto Díaz Orozco (Akiel) — Fri, 20 Jun 2025 14:40:16 +0000

The problem

I love homelabbing. If the term is new to you, it's basically building your own computers/network lab at home. Usually with consumer hardware or old and loud professional servers. Curious? Go visit http://reddit.com/r/homelab/ for addictive material that will make you want one.

My homelab runs services of all kinds, Kubernetes clusters, and experiments I make to study and prepare myself for work plus several things my family and friends actually use.

I do have a problem though: Every time my home router restarts or re-negotiates internet connection, my public IP address changes. This is very common for home internet connections and there's plenty of software to keep your records updated but, as always, I wanted something special.

My requirements

All the DDNS software I could find for Porkbun which is my current DNS provider is written in Python and not precisely well packaged. I need something easy to install and run that I can place anywhere with the minimum amount of dependencies needed.
I had no good way to monitor what's happening. Let's say I want to know if the process is not working well or if my credentials are not working, or just simply knowing when an update happened. Basically, I need metrics.
All the software I could find supports only one account and I didn't want to repeat the process for the several accounts I manage for my different labs. I need support for multiple accounts.

Getting my hands dirty

I think the first thing I liked about programming in Go is how portable the result is. I can just go ahead and focus on writing my software and I know it's probably going to work almost everywhere. I do like Python too, but, let's face it: it's just harder to distribute and to keep all the dependencies happy for applications. With Go you can just strip almost all system dependencies and package only your application.

So, I decided to go ahead and write my own Porkbun DDNS client in Go.

🛠 Try it out

The tool is open-source and available on GitHub:
👉 jadolg/porkbun-ddns

Features

Multiple credentials are configurable so you can update records for multiple accounts.
You are not restricted to only one record to update.
It has IPv6 support.
You can expose metrics from it and build monitoring and alerting based on them:
Timeouts and update intervals are configurable for flexibility.
Extremely easy to deploy either just downloading the binary and starting it as a service or using Docker or snap with more options coming in the future.
All settings are controlled via this simple YAML file:

update_interval_minutes: 5
timeout: 20s

credentials:
  prod:
    porkbun_api_key: changeme
    porkbun_secret_key: changeme
  dev:
    porkbun_api_key: changeme
    porkbun_secret_key: changeme

records:
  - domain: example.com
    host: www
    ipv6: true
    ipv4: true
    credentials: prod
  - domain: example.com
    host: blog
    ipv4: true
    credentials: dev

metrics:
  enabled: false
  port: 7879

Final words

I know this sounds like I’m advertising my own tool—because I am. But I built it to solve real problems I think many of you face too. I love writing tools that are useful, and I hope this one helps you as much as it’s helped me.

Monitoring Docker Hub limits with Prometheus

Jorge Alberto Díaz Orozco (Akiel) — Sat, 26 Apr 2025 23:12:22 +0000

The problem

Once upon a time, Docker decided to spoil us all developers and operators and had unlimited access to Docker Hub. You could pull as many images, as many times as your heart desired without any constraint, so we got used to it and never really thought about how good of a deal was that.

Unfortunately, free and unlimited almost never go hand to hand and the day came when Docker decided to impose limits to how much you can pull from the mothership. At this point (April 2025) the limits have changed twice and the current numbers can be found at https://docs.docker.com/docker-hub/usage/.

Many of us just created users for those machines with heavy docker pull usage and for most of it, it was fine. Until eventually something breaks. We started using caches where possible, but in some cases, the need for direct access was still there and therefore the need to know how much more can we pull for now and if any account had run dry.

Prometheus + Alertmanager + Grafana

If you've been operating services for the last decade, chances are you've meet these tools.
For the uninitiated:

Prometheus is used to collect metrics of your systems over time.
Alertmanager Takes care of handling alerts and distributing them to the right receiver.
Grafana Is used to visualize metrics, logs, traces, and by the time you read this probably other things 😄

These tools are widely used by operations teams as the backbone for monitoring and alerting and are the de facto standard in my opinion. This is not a tutorial about these tools specifically but I will explain how to pull the data into the tools and configure dashboards and alerts.

Prometheus exporters

Now, how do we get these metrics you ask? Well, we need to use a Prometheus exporter. This one specifically: https://github.com/jadolg/dockerhub-pull-limit-exporter.
Prometheus itself doesn't directly integrate with every service. Exporters are services that get information from other software/services and expose in a format that Prometheus understands. Once active, you can add the exporter as a target to your Prometheus server and it will start scraping metrics from it periodically.

Installing

The best and fastest way in my opinion to deploy the exporter is using docker compose. In your server (that already has docker and docker compose available), create a directory to place the configuration:

mkdir dockerhub-pull-limit-exporter
cd dockerhub-pull-limit-exporter

Download the example configuration

wget -O config.yaml https://raw.githubusercontent.com/jadolg/dockerhub-pull-limit-exporter/refs/heads/main/config.example.yaml

And replace the example credentials with yours. You can add as many accounts as your heart desires.

You can also adjust the interval in which the exporter gets its information from DockerHub and the timeout for these requests.
Once the configuration is in place, We need a docker compose file.

services:
  dockerhub-pull-limit-exporter:
    image: ghcr.io/jadolg/dockerhub-pull-limit-exporter
    restart: unless-stopped
    ports:
      - 9101:9101
    volumes:
      - ./config.yaml:/config.yaml

Save it into the same directory and start the service:

docker compose up -d

Prometheus

And now it's time to setup Prometheus. There are many ways to do this since there are many ways to install Prometheus in the first place, but the general idea is the same. We need to add the exporter as a target to our Prometheus server so it knows what to scrape. Edit your Prometheus configuration and add the following target to your scrape_configs replacing my-server with your server's address:

scrape_configs:                                                                                                         
  - job_name: 'dockerhub_pull_limit_exporter'
    static_configs:
    - targets: ['my-server:9101']

After restarting Prometheus, the new metrics should available.

Grafana

Now let's see what the metrics have to say. Head on to your Grafana and in the Dashboards section click New/Import:

In the Import view use ID 23342 (created specifically for this exporter) and click Load and then Load (Weird choice of options, I know). Dashboard can also be found in Grafana's site.

If everything goes right and your metrics are available you should be greeted by a shinny new dashboard like mine:

Alerts

Now we are collecting the data and we are able to see it but we need to get alerted when our limits are running low. In order to do that we need to add a new rule file to our Prometheus configuration:

rule_files:
  - "alerts.dockerhub.rules.yml"

And in that file we'll add the following alerts:

groups:
  - name: DockerHubPullLimits
    rules:
      - alert: DockerHubPullsRemainingLow
        expr: dockerhub_pull_remaining_total/dockerhub_pull_limit_total * 100 < 10 
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Account {{ $labels.account }} has used 90% of its pull limit"
      - alert: DockerHubPullsRemainingLowCritical
        expr: dockerhub_pull_remaining_total < 1
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Account {{ $labels.account }} has used 100% of its pull limit"

Restart Prometheus and the alerts should be loaded.

These alerts will be triggered when the accounts have used 90% of the current limit and then when they have used 100%.

Next, configure Alertmanager to route this alert to your favorite notification channel and alerts will get to you when they trigger.

Final words

Collecting metrics is an essential part of operating any software system. It's the window to your service's health and performance, and should be the main tool to use to diagnose when things go wrong. If there's a problem, there should be an alert for it and that alert should be based on metrics.

With all this in place, the next time my services run out of docker pulls, I will know immediately, and if they are failing, I will have all the information I need to know if this is the cause. I will also have historical data which I'll be able to analyze to know what the trending usage is and be ready to improve my setup based on that data.

And that's all for today folks! Happy monitoring!

cover image: https://www.freepik.com/free-vector/switches-buttons-control-panel-vector-illustrations-set-retro-control-console-terminal-elements-dials-knobs-dashboard-system-monitor-display-technology-equipment-concept_28480839.htm

Hunting down performance issues. A small DevOps story.

Jorge Alberto Díaz Orozco (Akiel) — Sat, 13 Apr 2024 20:33:15 +0000

The problem

Here comes the story of another operation:

One of my services (I both develop and operate it) frequently does "checks" on proxies through another service. This means a lot of service calls and some cryptography happening in the background so I was expecting it to use the CPU. The odd thing I was not expecting is that it did many many checks. For context, The check cycles were taking hours.

This had me puzzled for some time and it was impacting the performance of the whole server, so the first step consisted in just limiting the amount of CPU that the container could use so it became a good neighbor. The performance hit was not critical, but it was unacceptable.

Patching the roof

Since the service is running on docker-compose, the solution, was rather simple:

    deploy:
      resources:
        limits:
          cpus: "2"

Adding this to my service guarantees it won't hug all 4 cores in this server, but, as you can see in the following chart, the problem remained:

Dig deeper!

The amount of checks per second went down and all the other operations in the server were more responsive, but the time of the check bursts went very much up. We still have a problem to fix, we just made it good enough so the impact is not damaging the quality of the service.

The next step would be to check the logs and surprise, my logs were not that good or easy to check, so I decided to start logging into the database the times for every task I executed. To my surprise, the task I thought was a long-running task because the previous chart, was only behaving like that because it got constantly re-scheduled. It was able to finish in about 15 minutes, but then I had many of these 15-minute tasks all over the logs.

The solution

Turns out Celery was scheduling the task over and over again. In the end, I could not manage to configure Celery so it would not do this, so I decided to give alternatives a try and found huey and it worked like a charm. Almost no changes and it works as a complete in-place replacement at least for my use case (running one task every 20 minutes and another every 6 hours).

The performance improvement was so great I'm now able to schedule the task that previously was executed every 6 hours, every hour.

I still left the limit on CPU so if the service begins to misbehave again it does not affect its neighbors and I kept the new logs to have a more visible way to find problems.

Lessons learned

Without metrics, I would not even notice the problem. The platform was working "just fine", but the numbers didn't add up.
Question your metrics, even if they are on the baseline (it has always been like that). Your software might be misbehaving from the beginning and you will not notice the issue only by hunting irregularities.
Your logs are your best friends. The logs will tell you what's happening in the system. Keep them coming, but keep them lean. Too many logs are sometimes worse than too few.

And that's all folks. I hope you enjoy the read and I hope your services are up (and measured). Happy hacking!

Tunneling all your internet connections through a socks proxy

Jorge Alberto Díaz Orozco (Akiel) — Thu, 26 Aug 2021 17:11:08 +0000

A story

The seed of the problem

Not so many years ago when I used to live in Cuba, the only access to the internet I could use was using a Proxy set by the institution I was working for or the college I studied at. The managers on these networks used to restrict the contents you could access as hard as possible so at work you could not check Facebook or other social media, but that was not the main problem. Since Cuba is embargoed by the United States of America, several important resources like Docker images, Gitlab, and Google resources for coding in Android were all blocked for any Cuban IP. Conclusion: you need to use a VPN if you want anything done.
Not being able to pay for a VPS (no such thing as credit cards in Cuba) I was heavily using Tor, YourFreedom, or even an SSH tunnel if someone borrowed me their access to a VPS, and many other alternatives to circumvent censorship. Most of the time, these connections ended up in being a socks proxy either on my computer or my local trusted network, and I could use them easily from my browser or on several applications using tsocks or proxychains. But the holy grail of this problem was to get all the traffic from your computer to be tunneled only using a socks proxy, and that I could not achieve. Until now :-)

Recent development

What I could not foresee is that after all these years, a friend of mine would also face the same problem. As for today, two great alternatives for this are a good match in my opinion.
First, we have sshuttle and I absolutely love it. It helped me a lot during some time but it has a downside. It only works on top of SSH which is currently blocked by the only Cuban telecommunications company so we could not really use it.
Second, we have Outline and this one is also brilliant. I have read a lot about it because it seems it's heavily used to bypass censorship and all it is is a wrapper around a very nice set of tools. It basically sets a shadowsocks connection and configures your device so it behaves like a VPN. This seemed to be the right way to go, but for some odd reason, it did not want to work properly on my friend's computer.

Why not just using a VPN?

Well, Cuba is not precisely happy about their citizens using tricks to bypass their censorship and control, so they have managed to block protocols like OpenVPN. Every VPN that uses a handshake/header which is easily identifiable can be easily blocked. We could set up some obfuscation on top of the VPNs but this will require our users to also set up something on their side and that's "just fine" for a tech-savvy person, but not for our elders. In most cases, Outline is just perfectly fine because it's very hard to identify or block shadowsocks.

Making it work on a broken Linux

Most people will just re-install their OS and try again, but this time that was not an option. Also, I really wanted to fight this problem again, so, since Outline was the fittest option, I decided to go on and see what they are doing under the hood. They are open source (https://github.com/Jigsaw-Code/outline-client) so this was kind of an easy task.
Sadly, we could not isolate the problem in my friend's computer, but we were able to reproduce what the Outline folks do, and here's a guide to that:

Just tell me how to do it already!

Start a shadowsocks server if you don't have one set already ss-server -p 6276 -k password. The IP address of this server is going to be $server_ip from now on.
Install the shadowsocks-libev package. This will provide you with all the shadowsocks utilities and will set up your local proxy connected to the shadowsocks server.
Install badvpn-tun2socks. This application will tunnel all your data using a Tun network interface in Linux. To install it clone their repository https://github.com/ambrop72/badvpn and follow the compile and install instructions here.
Now, let's create a new tun network interface ip tuntap add dev tun0 mode tun user my_user, add an IP address to it ip a add 10.0.0.1/24 dev tun0, and bring the interface up ip link set dev tun0 up.
Connect to our shadowsocks server ss-local -s $server_ip -p 6276 -k password -l 1080 and give it a try curl --socks5 socks5://localhost:1080 https://myip.wtf/json. If it shows your server IP address it means it's working.
Start badvpn-tun2socks to start tunneling the data sent to tun0 to the socks proxy badvpn-tun2socks --tundev tun0 --netif-ipaddr 10.0.0.2 --netif-netmask 255.255.255.0 --socks-server-addr 127.0.0.1:1080. After this point you should be able to ping the virtual gateway ping 10.0.0.2 with successful results.
Add a network route to guarantee your socks proxy is still going to connect using your default gateway ip r a $server_ip via $default_gateway
Add a default route with a metric lower than the one provided by NetworkManager for your default gateway ip r a default via 10.0.0.2 metric 10 And this is it. After this point, all the connections on your Linux machine are routed to the tun0 interface and therefore to the socks proxy. Do a quick curl https://myip.wtf/json to check that you are in the location where your shadowsocks server is and enjoy another cup of coffee.

Final words

No, you probably won't need any of this if Outline works for you, but for me, it was very satisfying to finally beat this problem and to help my friend. We could not find why Outline was not working for him, but we managed to reproduce almost exactly what Outline does and had fun in the process.
Did you enjoy reading? Leave a <3 for me on this post and share it with your nerdy friends :-)

Avoid alert fatigue in your CI/CD

Jorge Alberto Díaz Orozco (Akiel) — Tue, 09 Feb 2021 12:06:23 +0000

TL;DR

My team was having issues with not meaningful notifications for our builds getting in our way and we built a GitHub action to fix it.

A story

All those essential meetings are over. You finally have the time to focus and do some coding. One of your teammates volunteers for working in pairs and together start building that new feature everyone is so eager to get. Ten minutes into analyzing the task a chime sounds and a Slack notification shows on your screen. It is the alerts channel for your project's builds. Other teammates have just pushed code for their task and it has built correctly. Their code is now deployed and everything seems fine. You close the notification and continue with your task, but the rest of the team is also moving and before you notice, you have checked the notifications channel five times in the last hour only to see green builds.

You think, let's just turn on notifications only for the broken builds so I don't waste my time checking things that are not broken, but after some days with this approach, you notice two problems: You don't find out if the status of the builds is green again if you don't manually check and now it feels sad to check the channel and see only red statuses of broken builds. You also want to know when there has being a recovery. The problem: There's no simple way of doing it with GitHub actions which is what the team is using for CI/CD.

Do this story rings a bell for you?

A solution

Lucky for us, GitHub Actions is a very flexible platform and the GitHub API helps a lot in finding information about your projects and builds. At this point, we decided to make our own action to tell us if we should notify Slack about the current build status.

This is the strategy we wanted to apply:

If the current build failed, then it will recommend sending the message
If the current build succeeded, and the previous one failed, then it will recommend sending the message
If the current build succeeded, and the previous one succeeded, then it will recommend NOT sending the message

With this stated, we can move onto the next step which is finding the right GitHub tools to build our action. Turns out that actions don't provide previous builds information out of the box, but we can always query the GitHub API and so we did. Turns out there's an API endpoint that will tell you the status of the runs for a specific workflow. For this, we need the current workflow id (which for some reason is not injected in the context by GitHub) but we can also get it from the information we get when querying for the current workflow run using this API endpoint.

With the previous build information, we now only need to check if any of the jobs for the build that are required have failed. For this, we will use in our job the needs property and the strategy here is passing it to our action and searching for the word failed there. If any of the jobs needed failed then we need to send a notification.

Show me how to use it already!

Here is what we ended up writing https://github.com/marketplace/actions/should-i-notify-slack and you can use it too in your actions since we decided to publish it and make it open source.

In the following example, we have two jobs in our workflow and we need to send notifications according to the previously discussed conditions. To accomplish this we

Add a third job that sends the notification (slack-workflow-status)
Add a condition to run this job even when the other jobs fail (if: always())
Add job1 and job2 to the needs of the slack-workflow-status job
Use our action to determine if we send the update to slack adding the condition if: steps.should_notify.outputs.should_send_message == 'yes' to the actual notification step which in our case uses the Gamesight/slack-workflow-status action.

Please notice that the example is using only the main branch:

job1:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v2
    - name: Run the script
      run: ./script1.sh
job2:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v2
    - name: Run the script
      run: ./script2.sh

slack-workflow-status:
  name: Post workflow status To Slack
  needs:
    - job1
    - job2
  if: always() && github.ref == 'refs/heads/main'
  runs-on: ubuntu-latest
  steps:
    - name: Determine if we need to notify
      uses: Jimdo/should-i-notify-action@main
      id: should_notify
      with:
        branch: main
        needs_context: ${{ toJson(needs) }}
        github_token: ${{ secrets.GITHUB_TOKEN }}

    - name: Slack workflow notification
      if: steps.should_notify.outputs.should_send_message == 'yes'
      uses: Gamesight/slack-workflow-status@master
      with:
        repo_token: ${{secrets.GITHUB_TOKEN}}
        slack_webhook_url: 'https://hooks.slack.com/services/...'
        channel: 'notifications-slack-channel'
        name: 'Your great build bot'

Final words

It might seem like having meaningless notifications is not such a big problem but it actually is. Whenever this happens, you and your team will start ignoring them and will notice the problems later than expected. Cutting the notifications/alerts to only what is important is crucial for effectively handling problems when they occur and to protect your focus time from distractions.

^{Cover image from https://www.recordedfuture.com/security-operations-alert-fatigue/}

Improving my home-office environment with noise detection

Jorge Alberto Díaz Orozco (Akiel) — Tue, 02 Feb 2021 20:31:32 +0000

TL;DR

I used a BBC micro:bit v2 to notify me when I am speaking too loud. Here is the project: https://github.com/jadolg/sound-alert-microbit

Why?

I usually don't speak too loud. Even when I'm mad, I try to remain calm and not to increase the volume of my voice as I dislike loud folks myself. There are, anyway, moments in which I involuntarily do speak really loud: When I'm wearing headphones and when I get really excited about what I'm talking about. And, guess what: That's exactly my everyday scenario since COVID19 forced us to close the offices and work from home. I work remotely for a fantastic software company and yes, my work is really exciting. On top of that, we do a lot of pair programming and have tens of meetings every week to discuss what we want to do and how we want to do it. All of this while wearing headphones that isolate me pretty well from the environment, so as you can imagine, I started speaking really loud.
This whole situation was not really fun especially for my wife. She is also a software engineer and we share the same space for working.

Just imagine having meetings at the same time 😬

What to do

I needed to do something regarding this issue and engineers will try to solve everything with tech right? I researched for some hours and found out that the BBC micro:bit had released a new version of their development board. What was specifically so nice about this board is that it comes already packed with a bunch of sensors including a microphone. This also comes with a very nice price tag and a system so simple to use even kids can do it.

Using MakeCode

You don't know how to code? No problem, you don't need to write a single line of code. Microsoft MakeCode will allow you to express your automation desires in an intuitive way. After some minutes, this is what I ended up with:

It is also very useful having an emulator and being able to play around and try everything.
MakeCode also allows you to code your solution in Python and JavaScript and applies translation from one codebase to another, so what I have just shown you in blocks looks like this in Python:

sound_enabled = False
sound_level = 0

def on_button_pressed_a():
    global sound_enabled
    sound_enabled = not (sound_enabled)
input.on_button_pressed(Button.A, on_button_pressed_a)

def on_forever():
    global sound_level
    sound_level = input.sound_level()
    if sound_level > 100:
        if sound_enabled:
            music.play_tone(262, music.beat(BeatFraction.WHOLE))
        basic.show_icon(IconNames.EIGTH_NOTE)
    else:
        basic.clear_screen()
basic.forever(on_forever)

and like this in JavaScript:

let sound_enabled = false
let sound_level = 0
input.onButtonPressed(Button.A, function on_button_pressed_a() {
    sound_enabled = !sound_enabled
})
basic.forever(function on_forever() {
    sound_level = input.soundLevel()
    if (sound_level > 100) {
        if (sound_enabled) {
            music.playTone(262, music.beat(BeatFraction.Whole))
        }
        basic.showIcon(IconNames.EigthNote)
    } else {
        basic.clearScreen()
    }
})

As much as I want to explain much more, I would be only grasping the surface of this great tool, so go and give it a try 😄

Final result

I ended up with a pretty cool gadget that warns me visually if I'm being too loud and with the press of a button I can set it so it also beeps at me. I'm trying to condition myself to be a better home-office mate for my wife. At this point, I think I have not made much progress at it 😅 but this is only the beginning.
You can find the code for the project in this repository (which MakeCode allows you to do) and explore and play with it.

^{Kudos to Clem Onojeghuo for the cover picture}

Decode JSON Web Token in your terminal

Jorge Alberto Díaz Orozco (Akiel) — Sat, 31 Oct 2020 19:16:16 +0000

Inspiration

Probably there are tens of applications to do this. I know for sure they are out there, but at the time I was reading this post on Reddit about how to get the downloads limit on DockerHub I could not find any of them. The requirements were pretty straight forward. I need one application I can push a token and it will output formatted JSON. No validation or fancy things required. I would love to colorize the output, but that's completely optional.

And out of this need, I got my Saturday project on.

We don't need to re-invent the wheel. Decoding is already done by a lot of libraries, I just needed to pick one and wrap everything in a nice GO CLI interface.

Development

One of the main reasons why I love to use GO is because I can build my applications for almost any platform/architecture. The binaries are a bit "fat", but let's face it: Storage is already pretty cheap and most people will just not care about a couple of megabytes.
I ended up searching for a nice library to do all the work for me and found go-jose. This decodes my token without problems and places all the claims into a GO map structure which I can later marshal as JSON.

var claims map[string]interface{}

token, err := jwt.ParseSigned(tokenString)
if err != nil {
    return "", err
}
err = token.UnsafeClaimsWithoutVerification(&claims)
if err != nil {
    return "", err
}

Well, all the hard work is done. Let's grab a beer and enjoy :-)
I added an argument -t to pass the token to my application:
tokenArgument := flag.String("t", "", "Token to decode. If not specified will try to read it from stdin.")
And some code to read from stdin if the token was not specified using the command line argument.
Then added optional colorization because life is better with colors, so I used TylerBrock/colorjson to optionally output colorized text.

Testing

I was a bit lazy here, so I just added some tests to check that the main methods are still doing what they are supposed to do, added a GitHub action to build and test the application every time someone pushes it or creates a pull request, and that is it.

Releasing

There are tons of ways to release applications. So many package managers and intricate ways maintainers have decided they want their software to be installed. For now, I'll just release the binaries and the users just need to download them and use them as they want. There's also a GitHub action for releasing GO applications (https://github.com/wangyoucao577/go-release-action) that worked perfectly for me. In the future, I'll be adding at least Ubuntu snaps support.

How to use

As my requirements were pretty simple the usage of the application is also simple. Just pass the token as an argument jwt-decode -t "ABeautifulToken" or pipe it in echo "ABeautifulToken" | jwt-decode and it will do the work. Want colors? Use it with -c and it will be 150% better.

Conclusion

And that's it. This is the result of my today's adventure trying to make everything nicer for me and my fellow devs. Feel free to leave some love materialized as GitHub stars for me.
You can download the proper binary for your distribution and start decoding JSON Web Tokens like a jedi from your terminal today from the GitHub release page.

A GitHub action to push messages to Rocket.Chat using credentials instead of webhooks

Jorge Alberto Díaz Orozco (Akiel) — Fri, 14 Aug 2020 21:46:41 +0000

My Workflow

So I found out about #ActionsHackathon thanks to a coworker ;-) and I like hackathons and stickers. I have been playing with GitHub actions during the last weeks and I was intrigued about how all of it works. I have worked with Travis, Bamboo, Gitlab-ci. It does not feel like any of them. That's why I decided to go with building an action myself.

I selected a problem I like and that I have talked about before here and started playing around. I love Rocket.Chat and I love chat notifications and the fact that you can notify a lot of people with a single message if your build breaks or if a new version of your application was deployed for testing is very convenient. Rocket.Chat allows you to add integrations and push messages using webhooks and they actually have a very nice GitHub action to do so. But what if you can't create integrations on this server because you don't have enough privileges? I wanted to be able to do it with only credentials, the URL for the Rocket.Chat server and the name of the channel where I want to post messages.

First, I'm not comfortable with using javascript or typescript and most of the actions I found were written using either of them. I was very happy when I discovered you can just use Docker https://docs.github.com/en/actions/creating-actions/dockerfile-support-for-github-actions

I started a new repository and begun writing with the code on the tutorial. Since I created a private repository I could only test the action on itself, so I started a disposable branch on GitHub, created a pull request to use my action, and started playing with different configurations from the same GitHub interface. I would commit the changes to the action on the master branch and then test from the disposable branch.

After a couple of hours, I had written and tested my new action and published it to the marketplace here.

It was fun working on it and the documentation was easy to follow. Now it's time to start actually using it on a project, showing it around and improving it :-)

Submission Category:

DIY Deployments

Yaml File or Link to Code

https://github.com/jadolg/rocketchat-notification-action

Additional Resources / Info

Open source projects involved:

TextMadeWeb: A website to browse the web while using a terrible internet connection

Jorge Alberto Díaz Orozco (Akiel) — Tue, 17 Mar 2020 16:37:32 +0000

A small introduction

You are probably tired of me saying how bad the internet connection is overall in Cuba, so I'll skip a bit that part today :D
A few years ago I was working with a terrible internet connection. I could not have better and loading pages on StackOverflow took minutes. Can you imagine? I was so frustrated and accomplishing so little at the time that I decided to fix the problem the way I know how to: programming a solution.

Here goes the testing

When I was in college I used to use iptables to control my internet traffic. That way I could decide what I wanted to consume and reduce my internet consumption to save the scarce amount of megabytes (100) I was getting every month. Yes, I'm NOT talking about speed. That's the actual amount of megabytes I could use every month.
So my first idea was to reuse my old iptables script with lots and lots of blocked addresses. But this eventually became problematic. I needed to again start to update my lists with new addresses and deprecate some that didn't even exist anymore. It was also not portable, so I could not give it to my friends using Windows. I scratched that one really fast from the list.
My second thought was to make a proxy to do the whole thing for me. I could distribute it or share it with my friends without problems but again updating it would be problematic so I again decided not to go that way.
At the time, a lot of my friends were also using these web proxies to bypass blocked sites so I had the idea of making something like that but to strip the webs of everything but text (and some styling because reading code in plaintext is a natural cause for headaches).

The product

I'm a lazy person :-) I know I should not be proud of it, but somehow I am. Being lazy makes you work extra to find a way to do things with less effort. In my case, I just realized that If I used a library to turn HTML into Markdown and then back to HTML, the result was tremendously clean. I just needed to then remove the images and trick the links so they will open inside the same site. I added a bit of compression and that's it.

Here is the result:

No styles, no images, no Javascript. Just plain text. You can find it hosted on https://txtmdweb.herokuapp.com/

You introduce the address that you want to "textify" and hit the "Text it!" button. The result will be something like this:

You can also do Google searches with it, but it is not particularly good at it :')

I used Django (1.11 at the time) to write the project and the sources can be found here

Disadvantages

I only implemented getting sites. No further interactions are permitted, so no login or cookies or anything but clear text which is publically available.
No Javascript. Sadly, a lot of websites today are mostly Javascript. If the website you are trying to convert to text is using Javascript to load its content, this is not going to work.

Conclusion

I hope you liked the story and if you are in need of using such a tool (I really hope you are not), well now you know it exists.
Want to make it better? PRs are open ;-) or just go open an issue.
And that's all. If you liked the project, go hit that star button on GitHub which makes open-source developers like me very happy.

Monitoring my internet connection with Micropython and ESP8266

Jorge Alberto Díaz Orozco (Akiel) — Mon, 23 Dec 2019 12:49:14 +0000

A small introduction

I love playing with IoT devices. Coming from Cuba that's not a corresponded love. It is really difficult to get your hands on them as they are usually not sold on any market. Some projects like The Cuban Tech Group have been doing an amazing job bringing tech and knowledge for all the interested parties for free but there is still a huge lack of development in that matter in the island. Thanks to some friends I managed to acquire some ESP8266 modules and I have played with them a lot. Micropython is an awesome tool to work with them and since I already knew Python and did not want to dig into learning how to code with all of the Arduino stack I limited myself to learn how to do things with micopython on these fantastic boards.

And the story actually starts

Some months ago I visited my parents in the countryside Cuba. I was very happy because they have managed to do a contract with the telecommunications company to have an ADSL connection at home. ADSL is now coming to Cuba and the service is pretty new. Users not only have to pay for the connection on a monthly bases but they also need to login on a captive portal that works per time (yes, this telecommunications company is evil and greedy and it's the only telecommunications company in the country). Since you need to pay per time and every hour of internet costs 0.5 USD, my parents can't afford to have it connected all the time, so they only use internet during some small periods of time during the day. And then there was me wanting to be notified when I could use the wifi to save my data internet which is also very expensive in Cuba.

I wanted to have some sort of indicator that will tell me when the ADSL router was actually connected to internet so I could use it and it needed to work even with me connected to another access point as I would probably be using internet from my phone almost all the time, and so, the idea came to my mind: Let's make a notification light with one ESP8266 board!

How should I check?

Well, there are lots of recipes to check if you are connected to internet, but here goes my preferred one: I once found this Google URL http://clients3.google.com/generate_204 that serves a simple purpose. Whenever you access it, the HTTP response code will be 204. So I'll just periodically check this URL expecting a 204 status code. If I get a 200 (OK) it means the device is connected but I'm hitting the captive portal and if I have any other response code or any connection error, well it means the problem is somewhere else. Probably the device is disconnected or there are some communications problems.

Here comes Micropython

First of all, I needed to flash micropython into my ESP8266 device (in my case a WemOS D1 mini) and you can find all the instructions on how to do it and how to start using the device here. Be patient. It's easy once you understand the process ;-)

Let's code

In the end, I ended up with this small script that will manage the on-board led according to the internet status:

import gc
import time
import network
import urequests
from machine import Pin

pin = machine.Pin(2, machine.Pin.OUT)
pin.on()

wlan = network.WLAN(network.STA_IF)
wlan.active(True)

while True:
    try:
        wlan.connect("user", "password")
        response = urequests.get("http://clients3.google.com/generate_204")
        print(response.status_code)
        if response.status_code == 204:
            print("online")
            pin.off()
        elif response.status_code == 200:
            print("portal")
            pin.off()
            time.sleep(1)
            pin.on()
        else:
            print("offline")
            pin.on()
    except:
        print("error")
        pin.on()
    gc.collect()

    time.sleep(10)

It will check every 10 seconds for a connection and let us know. I actually created a Github repository for it https://github.com/jadolg/IoTInternetMonitior so please feel free to comment, improve and use :)

Expected behavior:
When the router is connected to internet the status led will be ON. When the captive portal is detected the status led will blink and when there's an error in the connection and there's no internet access the led will be completely OFF.

Some things you probably noticed:
Yes, there's a lot of printing in there. Feel free to remove it as it's not really needed if you are not "old-style debugging".
Yes, for some reason the pin works completely in reverse so pin.on() is actually turning the led off.

Conclusions

I had a lot of fun building the indicator and in the end, even my parents ended up using it to figure out if they had correctly logged out of the internet service. I hope that someday we will not need this kind of device for anything in Cuba and that being connected all the time to internet will be cheap and easy. Since it is sort of a hacky story about solving a problem with tech I decided to share it with you. I hope you enjoyed reading.

Image credits to https://www.etsy.com/ . https://www.etsy.com/il-en/listing/537115947/offline

RocketChat notifications on your CI/CD pipeline

Jorge Alberto Díaz Orozco (Akiel) — Fri, 12 Oct 2018 16:47:48 +0000

Hey there :)
I'm a big fan of Rocket.Chat. Such a big fan that I even wrote my own REST API wrapper to use it with Python and convinced everyone in my company to migrate from Slack. And since I work in a software house we soon started using it for many things. We even have a bot to set up reminders in the organization :)
One thing we love about the work we do is continuous integration. We are a very quality focused team and we like everything to be automated. I want to do git push and everything should automagically start building, testing, measuring and deploying and I, of course, want to have notifications on my awesome chat application so my team is also aware of what's going on without even opening our CI tools.
I know there are plenty of CI tools, but one of the more popular in my team is gitlab-ci. I personally switched from jenkins because I loved the way gitlab works all with Docker out of the box and I find the sintax more clear and beautiful, therefore I will write my examples using gitlab-ci notation.
So, you can technically push notifications to RocketChat using only curl, but it will probably be verbose. First, you would have to login into your chat server and save the tokens and then post the message you want, all using, for instance, curl.
According to the REST API documentation, you would log in like this

curl http://localhost:3000/api/v1/login \
     -d "username=myusername&password=mypassword"

which will result in a response like this:

{
  "status": "success",
  "data": {
      "authToken": "9HqLlyZOugoStsXCUfD_0YdwnNnunAJF8V47U3QHXSq",
      "userId": "aobEdbYhXfu5hkeqG",
      "me": {
            "_id": "aYjNnig8BEAWeQzMh",
            "name": "Rocket Cat",
            "emails": [
                {
                  "address": "rocket.cat@rocket.chat",
                  "verified": false
                }
            ],
            "status": "offline",
            "statusConnection": "offline",
            "username": "rocket.cat",
            "utcOffset": -3,
            "active": true,
            "roles": [
                "admin"
            ],
            "settings": {
                "preferences": {}
              }
        }
   }
}

and you would need to save the values of authToken and userId to be used to post the message.
Posting the message after this using curl is also not difficult:

curl -H "X-Auth-Token: 9HqLlyZOugoStsXCUfD_0YdwnNnunAJF8V47U3QHXSq" \
     -H "X-User-Id: aobEdbYhXfu5hkeqG" \
     -H "Content-type:application/json" \
     http://localhost:3000/api/v1/chat.postMessage \
     -d '{ "channel": "#general", "text": "This is a test!" }'

It should be very easy to make a script with this, but since I wanted to practice some GO I decided to make this application and since I love the way GO just works almost everywhere it seemed like a good idea and it was.
So the idea now is a little bit more simple:
You just have to download the released application (or compile it yourself) and executed as shown in the help.

wget https://github.com/aleph-engineering/rocketchat-notification/releases/download/1.4.1/rocketchat-notification -P /usr/bin/ && chmod +x /usr/bin/rocketchat-notification

and

rocketchat-notification -c general -u user -p ${ROCKET_PASSWORD} -s https://myserver.rocket.chat -m "hello from terminal"

Pretty simple right?
Now let's use it in a sentence :)
On my gitlab-ci (.gitlab-ci.yml on your files) I would do something like this:
First, let's put the password of the user we want to use as an environment variable on gitlab so it is not persisted on our files improving our security:
This is done on our project's settings under CI/CD

And let us write in our .gitlab-ci.yml something like this:

stages:
- test

image: docker:stable-dind

test_nitofication:
  stage: test
  before_script:
  - wget https://github.com/aleph-engineering/rocketchat-notification/releases/download/1.4.1/rocketchat-notification -P /usr/bin/ && chmod +x /usr/bin/rocketchat-notification
  script:
  - rocketchat-notification -c general -u gitlab -p ${ROCKET_PASSWORD} -s https://yourserver.rocket.chat -m "hello from CI"

Commit and push your changes and wait for the notification :)

Do you want to send the output of a command to your chat? No problem. You can always run rocketchat-notification to read from standard input like this:

docker ps | rocketchat-notification -c general -u gitlab -p ${ROCKET_PASSWORD} -s https://yourserver.rocket.chat

and using the -code true flag your text will appear in a codebox in the chat.
And that's it. I hope you find this interesting and practical and have fun with your Continuous Integration.