DEV Community: Dan Benitah

Fixing Podman Image Pulls Behind Zscaler on Windows

Dan Benitah — Wed, 09 Sep 2026 08:24:32 +0000

When using Podman on Windows behind Zscaler, image pulls can fail because the Podman Linux VM does not trust the Zscaler root certificate, even though Windows does.

> podman pull --tls-verify=false mcr.microsoft.com/k8se/services/codeinterpreter:0.9.18-python3.12
Trying to pull mcr.microsoft.com/k8se/services/codeinterpreter:0.9.18-python3.12...
Error: unable to copy from source docker://mcr.microsoft.com/k8se/services/codeinterpreter:0.9.18-python3.12: initializing source docker://mcr.microsoft.com/k8se/services/codeinterpreter:0.9.18-python3.12: pinging container registry mcr.microsoft.com: Get "http://mcr.microsoft.com/v2/": proxyconnect tcp: dial tcp: lookup socks=127.0.0.1: no such host

Using --tls-verify=false may not be enough. The reliable fix is to export the Zscaler CA from Windows and install it into the Podman VM.

1. Find the Zscaler certificate

In PowerShell:

$cert = Get-ChildItem Cert:\CurrentUser\Root |
    Where-Object {
        $_.Subject -match "Zscaler" -or
        $_.Issuer -match "Zscaler"
    } |
    Select-Object -First 1

$cert | Format-List Subject, Issuer, Thumbprint

If it isn't present there, also check:

Get-ChildItem Cert:\LocalMachine\Root |
    Where-Object {
        $_.Subject -match "Zscaler" -or
        $_.Issuer -match "Zscaler"
    }

For me it was called Zscaler but I do not know what the convention is. So if it cannot find it, try and open regedit to check for an equivalent.

2. Export it as PEM

$cerFile = "$env:TEMP\zscaler.cer"
$pemFile = "$env:TEMP\zscaler.pem"

Export-Certificate `
    -Cert $cert `
    -FilePath $cerFile `
    -Force

certutil -encode $cerFile $pemFile

The resulting file should contain:

-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----

3. Install it into the Podman VM

Start Podman if necessary:

podman machine start

Encode the certificate so it can safely be sent through SSH:

$pem = Get-Content $pemFile -Raw

$base64 = [Convert]::ToBase64String(
    [Text.Encoding]::ASCII.GetBytes($pem)
)

Then install it into the Podman VM trust store:

podman machine ssh `
    "echo '$base64' | base64 -d | sudo tee /etc/pki/ca-trust/source/anchors/zscaler.crt > /dev/null && sudo update-ca-trust"

4. Verify connectivity

Test HTTPS from inside the Podman VM:

podman machine ssh "curl -Iv https://mcr.microsoft.com/v2/"

A 401 Unauthorized response from /v2/ is fine — it means TLS and connectivity are working.

You should no longer see errors such as:

certificate signed by unknown authority

5. Pull the image normally

For example:

podman pull mcr.microsoft.com/k8se/services/codeinterpreter:0.9.18-python3.12

No --tls-verify=false is required.

Why this works

Podman on Windows runs Linux containers inside its own Linux/WSL VM. Windows may already trust the corporate Zscaler CA, but the Podman VM has a separate certificate trust store.

Installing the Zscaler root CA under:

/etc/pki/ca-trust/source/anchors/

and running:

sudo update-ca-trust

allows Podman and other tools inside the VM to validate HTTPS connections intercepted by Zscaler normally.

Reachy PizzAIolo: When a Restaurant Sign Starts a Conversation

Dan Benitah — Mon, 24 Aug 2026 23:21:02 +0000

Reachy PizzAIolo: When a Restaurant Sign Starts a Conversation

Building an AI-powered conversational restaurant ordering experience with Reachy Mini and Seeed Studio's reTerminal E1003.

What if a restaurant sign didn't just display the menu?

What if it could talk to you, understand what you wanted, help you make a choice, update your order as you spoke - and show everything visually at the same time?

That is the idea behind Reachy PizzAIolo.

It combines the personality and conversational abilities of Reachy Mini Lite, the physical presence of the Seeed Studio reTerminal E1003, and an AI-powered ordering service to explore a slightly different idea of interactive signage:

a sign you can actually have a conversation with.

🍕 Why Reachy PizzAIolo?

I built Reachy PizzAIolo as my entry for Seeed Studio's Interactive Signage Contest 2026.

This year's contest focuses specifically on restaurants and dining, asking makers to rethink what interactive signage could become when combined with technologies such as AI, voice interaction, sensing and IoT.

That immediately made me wonder:

Why should the interaction start with the screen at all?

Touchscreens are already everywhere in restaurants. They work well, but increasingly they feel like another computer interface placed between the customer and the restaurant.

A conversation is different.

You can say:

"I'd like a Margherita and a Coke."

Then:

"Actually, make that two pizzas."

Or:

"What vegetarian pizzas do you have?"

Or simply:

"That's everything."

So rather than building another digital menu, I wanted to see what would happen if conversation became the primary interface and the display became its visual companion.

And of course, if the robot taking your pizza order happens to look like Reachy Mini, there was only one sensible name:

Reachy PizzAIolo. 🤌

🎥 See it in action

The core interaction is deliberately simple.

A customer speaks naturally to Reachy.

Reachy understands the conversation, maintains an order, and communicates changes to the ordering service.

The E1003 updates to give the customer a persistent visual representation of what has been ordered.

Meanwhile, restaurant staff - whether in the kitchen or front of house - can see the order appear on the active-order dashboard.

The result is an interaction that combines:

conversation + physical character + visual confirmation + structured restaurant data

rather than relying on any one interface alone.

🍕 Putting it to the test at a real pizza party

One of the most enjoyable milestones for the project was getting to use Reachy PizzAIolo at an actual pizza party.

Rather than only testing the interaction as a controlled demo, Reachy was able to take orders from real guests in exactly the sort of social setting the project was designed for.

It was a simple but useful test of the idea: people could approach Reachy, place their order conversationally, and see that interaction turn into a structured order.

And, perhaps more importantly, it was fun. A robot taking pizza orders naturally became part of the experience rather than just another ordering terminal.

Reachy PizzAIolo on duty at a real pizza party.

🤖 Meet the team

Reachy Mini - the personality

At the front of the experience is the Reachy Mini Lite, the small expressive robot from Pollen Robotics.

Reachy provides something a touchscreen cannot: physical presence.

Its head movement, antennas, voice and reactions make even a relatively simple ordering interaction feel very different from navigating menus on a kiosk.

But Reachy isn't merely there as an animated mascot.

The conversation is connected directly to the ordering system.

When the customer adds, removes or changes something, Reachy isn't just generating a response - it is affecting the state of a real order.

Seeed reTerminal E1003 - the visual companion

Beside Reachy is the Seeed Studio reTerminal E1003.

The E1003 is particularly interesting for this project because it combines a large monochrome ePaper display with touch capability.

💡 Seeed Studio discount: If you're interested in the E1003, E1004 or Sticky, you can use code CFST3GPA for an additional discount where eligible.

In Reachy PizzAIolo, its main job today is live order review.

As the conversation progresses, the display reflects the current state of the basket.

That matters because voice interfaces have a weakness: spoken information disappears.

If Reachy says:

"I've added two Margheritas, one sparkling water and a tiramisu..."

the customer shouldn't have to remember all of that.

The E1003 turns the conversation into something persistent and glanceable.

You can talk to Reachy while still being able to look at the order.

This also creates the basis for something more interesting later: a genuinely multimodal ordering experience, where speaking and touching the display become interchangeable ways of modifying the same order.

🏗️ How it works

At a high level, the architecture is intentionally straightforward:

       Customer
          │
          ▼
    🤖 Reachy Mini
          │
          │ Conversation
          ▼
   🧠 Ordering Service / AI
        │             │
        │             │
        ▼             ▼
 🖥️ reTerminal     🍽️ Active
     E1003             Orders

The ordering service is the important layer in the middle.

Rather than treating the conversation as a stream of unstructured text, it maintains a structured representation of the customer's order.

That means the same order state can be used by several different interfaces.

Reachy can talk about it.

The E1003 can display it.

The restaurant dashboard can act on it.

And future interfaces could modify exactly the same underlying order.

🔄 A typical order

Imagine walking up to Reachy:

Reachy:
"Hi! Welcome. What can I get for you?"

Customer:
"Can I have two Margheritas and a Coke?"

The ordering service extracts the items and quantities and updates the active basket.

The E1003 now shows:

YOUR ORDER

2 × Margherita
1 × Coke

Then the customer says:

Customer:
"Actually, change one of the Margheritas to a Diavola."

Reachy updates the order rather than starting again.

YOUR ORDER

1 × Margherita
1 × Diavola
1 × Coke

And when the customer is ready:

Customer:
"That's everything."

Reachy can recap the order and move it into the restaurant's active-order workflow.

That ability to modify an existing structured state through natural conversation is one of the parts I find most interesting.

🖥️ The restaurant side

The customer-facing interaction is only half of the system.

Confirmed orders are also made available to an active-orders dashboard.

That turns Reachy PizzAIolo from a robot demonstration into the beginning of a restaurant workflow.

The important distinction is that the AI isn't merely producing a conversation.

It produces structured actions that another system can consume.

That opens up obvious future integrations with:

kitchen display systems
point-of-sale systems
payment
stock availability
menu management
loyalty programmes
table service
multilingual ordering

The robot is simply one interface into that system.

💡 Why combine voice and signage?

During this project, I increasingly found that the interesting part wasn't really the robot or the screen.

It was the relationship between them.

Voice is excellent for intent

It is very natural to say:

"Give me another one of those."

or:

"What do you recommend?"

or:

"No onions on that one."

Displays are excellent for state

A screen is much better at answering:

What have I ordered?

How many?

How much?

What choices are available?

So instead of asking whether voice or touch is the better interface, Reachy PizzAIolo explores what happens when each does the job it is naturally good at.

Conversation handles intent.

The sign provides context and confirmation.

✅ What works today

The current prototype implements the core end-to-end experience:

🎙️ Conversational ordering

A customer can build and modify an order by speaking naturally with Reachy.

🖥️ Live E1003 order review

The customer-facing E1003 reflects the current order as the conversation progresses.

🍽️ Real-time order dashboard

Orders flow through to a separate active-orders view for the restaurant.

Most importantly, these aren't separate demonstrations.

They are different views onto the same order state.

🚀 What's next?

There are several directions I would like to take this.

🎙️ Full-duplex conversation

At the moment, conversational turn-taking is more rigid than I ultimately want.

The next step is allowing the customer to interrupt Reachy naturally:

"Actually..."

and immediately correct or extend an order without waiting for the robot to finish speaking, while the system keeps track of the conversation so far.

That would make the interaction feel significantly closer to talking to a human member of staff.

👆 Truly multimodal ordering

The E1003 is touch-enabled, which creates a particularly interesting next step.

Imagine Reachy saying:

"We have four desserts - I've put them on the screen."

The customer could then either say:

"I'll have the tiramisu."

or simply tap it.

Both interactions would manipulate the same underlying order.

Conversation when conversation is easiest.

Touch when touch is easier.

No separate modes.

🧩 Skills-based orchestration

Restaurant conversations are deceptively complicated.

An ordering assistant needs to distinguish between actions such as:

searching the menu
adding an item
changing quantity
removing an item
checking availability
understanding modifiers
recommending something
confirming the order

I want to continue moving more of this behaviour into explicit, structured skills/tools, leaving the language model to understand the conversation while deterministic services handle the actual restaurant operations.

That should make the system both more capable and more reliable.

🧠 More local AI

Another direction I am particularly interested in is moving more of the AI stack to the edge.

A future version could use something such as Seeed Studio's reComputer Robotics J5012 as a local AI server for the restaurant.

To be clear: the J5012 is not part of the current implementation.

What interests me here is not necessarily putting a powerful AI computer behind every robot or display. Instead, a restaurant could potentially have one local AI machine serving the whole location.

That shared edge server could provide services such as speech recognition, text-to-speech, language models and AI orchestration to multiple Reachy or signage endpoints around the restaurant.

The customer-facing devices could remain relatively lightweight, while the more computationally intensive AI runs centrally within the store.

For a real deployment, that could offer an interesting balance between local processing and cloud services - potentially improving latency, resilience and privacy without requiring dedicated AI hardware at every ordering point.

🌍 Beyond pizza

Despite the name, there is nothing fundamentally pizza-specific about the architecture.

Reachy PizzAIolo is really an experiment in conversational interactive signage for restaurants.

The same pattern could work in:

cafés
bakeries
food courts
hotel breakfast areas
quick-service restaurants
reception desks
kiosks
visitor attractions

And Reachy doesn't necessarily have to be the final physical interface either.

The broader idea is a service where conversation, signage and structured business workflows all share the same state.

The pizzaiolo is simply a much more entertaining way to demonstrate it. 🍕

🛠️ Building it

I am making the project available so that the individual components and architecture can be explored and reproduced.

Source code

👉 GitHub:
https://github.com/danuw/reachy-pizzaiolo (Based on the reachy Mini conversation app) and https://github.com/danuw/reachy-pizzaiolo-e1003 (for the ePaper Touch Tablet E1003)

The repository contains the application code and will continue to receive documentation and setup instructions as I tidy the contest prototype into something easier for others to reproduce.

Hardware and resources

🤖 Reachy Mini Lite - the version used in this project
Seeed Studio product page – affiliate link

📖 Reachy Mini source and documentation
https://github.com/pollen-robotics/reachy_mini

🤖 Other embodied AI robots from Seeed Studio
Seeed Studio collection – affiliate link

🖥️ Seeed Studio reTerminal E1003
Product page – affiliate link

🏷️ Seeed Studio discount code
Use CFST3GPA for an additional discount on the E1003, E1004 or Sticky where eligible.

📖 reTerminal E1003 documentation
https://wiki.seeedstudio.com/getting_started_with_reterminal_e1003/

🏆 Seeed Studio Interactive Signage Contest 2026
https://www.seeedstudio.com/make-a-sign-interactive-signage-contest-2026

🎥 Project video
https://youtu.be/t1Ayfm52QaI

🙌 Final thoughts

I started this project thinking about how to make a restaurant sign interactive.

I ended up asking a slightly different question:

What if the sign stopped behaving like a screen and became part of the conversation?

Reachy PizzAIolo is still a prototype, but it has already convinced me that conversational AI becomes much more interesting when it escapes the browser.

Giving an AI a physical presence changes the interaction.

Giving the conversation a persistent visual surface makes it more usable.

And connecting both of those to a real structured workflow is what starts turning the demonstration into a product.

There is plenty more I want to explore - particularly full-duplex speech, touch + voice interaction, structured skills and local AI.

But for now...

Buon appetito! 🤌🍕🤖

Disclosure

This project was created as an entry for the Seeed Studio Interactive Signage Contest 2026. Some links in this article to Seeed Studio products are affiliate links. If you purchase through one of these links, I may receive a small commission at no additional cost to you. Where eligible, you may also be able to use discount code *CFST3GPA** on the E1003, E1004 and Sticky. This does not affect the opinions or technical information presented in this article.*

Tags: #ai #robotics #iot #opensource

Group chats are great for conversation. They are terrible databases.

Dan Benitah — Sat, 25 Jul 2026 23:22:46 +0000

Garcon began with a very familiar problem: organising food orders for a family evening.

Everyone sends their choices in a group chat. Some people change their minds, dish names do not quite match the menu, messages get buried, quantities are duplicated, and one person has to reconstruct the final order manually. When the food arrives, somebody inevitably asks:

“Where’s mine?”
“This isn’t what I ordered.”

That was the starting point for Garcon - Your Takeaway Order Copilot, which I built for OpenAI Build Week during the final stages of the 2026 World Cup.

Garcon lets an organiser review a menu, create an ordering event and share one secure link. Guests do not need accounts: they enter a name, make their selections, add an optional note and submit. The organiser receives both a per-person distribution list and aggregated quantities, with the totals reconciled between the two views.

Once I had the food-ordering flow working, I started noticing the same problem elsewhere. For example:

Preparing lunch or refreshments for an event at work.
Collecting choices for a school activity.
Planning food for a birthday or family gathering.
Estimating portions for homemade dishes, desserts or a potluck.

Garcon is still food-first. But the same small problem appears elsewhere: a group is choosing from a fixed list, and one person needs a dependable answer about who wants what and how many are needed.

I have not built the non-food versions yet, but I can imagine the same approach helping with workshop choices, school-event packs, clothing sizes or volunteer tasks. That feels like a natural direction for the idea rather than something the current application already claims to support.

Not every group decision needs a complex form builder. It should not require a spreadsheet expert either. And it definitely should not have to be reconstructed from multiple chat messages.

I built Garcon with React and Supabase, using ChatGPT to challenge and refine the idea and Codex with GPT-5.6 to implement it. Codex was particularly useful when working through the less visible details: securing the no-account guest flow, keeping prices on the server, testing submissions and deploying the application. ChatGPT Remote also let me continue resolving last-minute issues while I was away from my desk.

The result is live and usable: an organiser can create an event, share a no-login link, and see guest responses in both per-person and aggregated views. Behind the scenes, the menu is frozen for the event and prices are calculated on the server.

It may sound like a small problem. It is. But small logistical problems have a habit of taking over an otherwise enjoyable evening. If Garcon removes one of them, that is already useful.

OpenAI Build Week entry:
https://devpost.com/software/garcon-your-takeaway-copilot-4k8aot

Try the application:
https://garcon-ordering.danuw.chatgpt.site

Corrected demo video:
https://www.youtube.com/watch?v=8BzQ_Pnz48w

I would love feedback on where this idea could go next—especially other situations where collecting a group’s preferences becomes more complicated than it should be.

Dealing with "DevTools remote debugging is disallowed by the system admin"

Dan Benitah — Wed, 06 May 2026 16:53:39 +0000

Developers using Playwright (often alongside GitHub Copilot) in corporate environments may encounter the error “DevTools remote debugging is disallowed by the system admin.” This cryptic message usually means your company’s group policies are blocking Chrome or Edge from running in remote-debug/automation mode. In such locked-down setups, Playwright’s attempt to launch a Chromium-based browser gets shut down by admin rules, leading to that error in your test logs.

Quick Fix: Use WebKit Instead of Chrome/Edge

Rather than wrestling with IT to relax the policies or applying hacky workarounds, the easiest solution is to avoid the restricted browsers entirely. Playwright supports multiple browser engines (Chromium, Firefox, WebKit). By configuring the Playwright MCP server to run tests on WebKit, you bypass the corporate restrictions affecting Chrome/Edge. The WebKit engine that ships with Playwright isn’t subject to those admin policies (since they specifically target Chromium-based browsers), so your tests can run without hitting the “remote debugging disallowed” roadblock.

For example, update your MCP server config to specify WebKit as the browser:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": [
        "@playwright/mcp@latest",
        "--browser=webkit"
      ]
    }
  }
}

In plain terms, using WebKit avoids the issue because it’s a different browser engine (essentially Safari’s open-source core) that corporate group policies don’t block. With this one change, you can run your Playwright tests (even those generated via Copilot) smoothly – no more admin interference, just automated tests running as expected.

If this did not work for you, you can always edit the relevant registry keys, request to "Allow Browser Remote Debugging" or use the extension

Git clone - that repo is too big : HELP!

Dan Benitah — Tue, 03 Dec 2024 20:54:00 +0000

Working with large repositories can be challenging, especially when you only need a specific directory. Instead of wasting time and storage, here's a guide to efficiently clone sub-directories using git-sparse-checkout.

1. Clone the Repository with Sparse Checkout

Use the --depth 1 flag to clone only the latest commit, and --filter=blob:none to avoid downloading file contents initially:

git clone --depth 1 --filter=blob:none https://github.com/danuw/azure-docs.git --sparse

Resulted in following (note the size of 307 kiB downloaded when the repo is gigabytes heavy!!)

Cloning into 'azure-docs'...
remote: Enumerating objects: 8438, done.
remote: Counting objects: 100% (8438/8438), done.
remote: Compressing objects: 100% (7673/7673), done.
remote: Total 8438 (delta 51), reused 4682 (delta 25), pack-reused 0 (from 0)
Receiving objects: 100% (8438/8438), 2.56 MiB | 16.60 MiB/s, done.
Resolving deltas: 100% (51/51), done.
remote: Enumerating objects: 85, done.
remote: Counting objects: 100% (85/85), done.
remote: Compressing objects: 100% (81/81), done.
remote: Total 85 (delta 52), reused 16 (delta 4), pack-reused 0 (from 0)
Receiving objects: 100% (85/85), 307.16 KiB | 5.04 MiB/s, done.
Resolving deltas: 100% (52/52), done.

2. Navigate to the Cloned Repository

Change your directory to the cloned repository:

cd azure-docs

3. Initialize Sparse Checkout Mode

Enable sparse checkout in cone mode, which simplifies the process of selecting specific directories:

git sparse-checkout init --cone

4. Set the Directory to be Checked Out

Specify the directory you want to check out from the repository. In this example, we are checking out the articles/iot-operations directory:

git sparse-checkout set articles/iot-operations

Note: If you encounter an error, ensure that your Git version supports sparse checkout, that the specified directory exists in the repository or that the syntax is adapted to your local system (Windows, MacOS, Linux?...)

After these steps, only the files within the articles/iot-operations directory will be checked out into your local repository, minimizing the data you download and store.

remote: Enumerating objects: 189, done.
remote: Counting objects: 100% (189/189), done.
remote: Compressing objects: 100% (182/182), done.
remote: Total 189 (delta 10), reused 106 (delta 7), pack-reused 0 (from 0)
Receiving objects: 100% (189/189), 10.96 MiB | 21.30 MiB/s, done.
Resolving deltas: 100% (10/10), done.
Updating files: 100% (190/190), done.

Wrap up

This method is particularly useful when storage space is limited or when working with a slow connection. Whether you're cloning a specific lab version or just a part of a broader documentation set (e.g., for LLMs or RAG purposes), this guide offers a simple and effective solution.

Additional Notes

Originally published as a GitHub Gist.

For those following Microsoft documentation, this tip may soon be available directly across labs and tutorials, as seen in this example and its PR.https://github.com/dotnet/AspNetCore.Docs/pull/34239)

Upgrading Python version for your Microsoft Fabric environment

Dan Benitah — Thu, 12 Sep 2024 16:40:00 +0000

I was recently stuck trying to re-run a python notebook in Fabric using the Azure Event Hub package to upload data to a KQL database. The script, which had been running smoothly for months, suddenly stopped working after an environment change or update.

UPDATE: bringing forward this note as it should be a better solution to use

Note: I later found a note about my issue in some training training material, which had been my first solution without the --force parameter. That may be a better solution for you if you needed to keep the Spark Runtime unchanged https://github.com/microsoft/FabricRTA-in-a-Day/blob/main/Lab3.md#steps

The first issue I was facing was the following when installing the package in my notebook.

ERROR: pip's dependency resolver does not currently take into account all the packages that are installed

This error indicates that the package dependencies are conflicting, which often occurs due to Python environment version incompatibilities or misaligned dependencies.

When trying to import the package, I could see the environment was set to 3.10 (see below).
And when trying to create my own environment, I could not find azure-eventhub pypi package either (see here).

Eventually, I tried to figure out how to upgrade the python environment, and with the help of a friend, I was able to do so.

The solution was upgrade the PySpark environment.
It resolved the issue by updating the Python runtime to a compatible version with the azure-eventhub package. Switching to Spark Runtime 1.3 updated Python to version 3.11.x, resolving dependency conflicts.

How to change the Spark Runtime to 1.3

Go to the Workspace settings.
Select the appropriate runtime from the dropdown list.
Save and restart your notebook.

Validation of the Environment Upgrade

Now the changes have been apply, create a new notebook ensuring the selected environment uses the Spark Runtime 1.3.

# Check if the environment upgrade was successful
import azure.eventhub
print("Environment setup successful!")

Conclusion

Upgrading the Python environment in Fabric by changing the Spark runtime resolved the dependency conflicts I faced with the azure-eventhub package. If you encounter similar issues, adjusting the runtime version can be a quick fix. Remember to validate your changes and test your script to ensure everything is working smoothly.

References:

Speeding up installation of AIO (Azure IoT Operations) deployment using a script

Dan Benitah — Sat, 01 Jun 2024 23:57:05 +0000

If you're eager to learn more about AIO (Azure IoT Operations), which is currently in private preview, it's crucial to start with a fresh install to experiment quickly and efficiently. In this post, I will guide you through the steps to reinstall your cluster using a script, ensuring a smooth learning experience. Let's get started!

For now, the assumption is that you are using fresh codespace using those steps. Updated script for physical machines with Ubuntu server coming soon...

Setup the cluster again and deploy the AIO extension

Note: if your are looking at a new version of AIO, the script may need adapting - this has been tested with AIO v0.5-preview at the time of writing

1. Set up your variables

1.a RESOURCE_GROUP

When you created your Codespace, you had to provide some variable values such as the resource group, so double check that the resource group variable is what you expect with echo $RESOURCE_GROUP, and otherwise set it using (update value as needed):

export RESOURCE_GROUP=aio-codespace-rg

1.b IOT OPS USER_EMAIL

To ensure your user can access the AIO UI, specify your IoT Ops user email with the following command, replacing with your actual email address:

export USER_EMAIL=<your-email>

Note: Remember that user needs to be a member of the tenant such as iotops@YOUTENANT.onmicrosoft.com
If you do not have one, use export USER_EMAIL=$(az ad user create --display-name 'IoT Ops User' --password <PASSOWRD> --user-principal-name iotop@<TENANTNAME>.onmicrosoft.com --force-change-password-next-sign-in false -o tsv --query userPrincipalName)

1.c Other Variables (optional)

Consider double checking other environment variables such as the $CLUSTER_NAME to suit your preferences.

2. Login

Ensure you are signed into your Azure Account by running the following command in your terminal, then follow the instructions in your browser:

az login --use-device-code

3. Run your setup script

Create a file named setup.sh in your Codespace and copy the content from this gist into it.

Once you have updated your variables and logged into Azure, you are ready to run the script with the following command:

. ./setup.sh

Note: Currently tested on Codespace, but will soon update with script for Ubuntu server including Az CLI install and other pre-requisites for re-install

4. Manual Validation

Based on experience, if your Codespace setup remains unchanged (same number of cores, etc.), you can expect this whole process to take approximately 25 minutes.

After the process completes, navigate to IoT Operations Portal and sign in with your member user account. You should see your cluster listed as connected.

Next?

Thank you for reading this far. I hope this script helps you experiment faster with AIO. In the future, I plan to:

Expand the script with new steps: As AIO evolves and more APIs become available, additional processes can be automated. You may also consider improving the script as you explore or revisit the latest features, in which case don't forget to let me know in the gist's comments.
Cover more scenarios, such as creating assets using CLI.

References:

AIO : Unable to read /etc/rancher/k3s/k3s.yaml, please start server with --write-kubeconfig-mode to modify ... permissions

Dan Benitah — Thu, 02 May 2024 16:06:52 +0000

Using Azure IoT Operations (AIO) and found that issue of permissions denied and the cluster not running with the following messages? Here is how I fixed it...

When I connect to my clusters, my first action is to check if my pods or services are running with the following command, but recently I have at times been getting the subsequent output error:

$ kubectl get service -n azure-iot-operations
WARN[0000] Unable to read /etc/rancher/k3s/k3s.yaml, please start server with --write-kubeconfig-mode to modify kube config permissions
error: error loading config file "/etc/rancher/k3s/k3s.yaml": open /etc/rancher/k3s/k3s.yaml: permission denied

I tried the following solution using this command, but that was only temporary...

Solution 1: Admin Kubeconfig Options

sudo k3s server --write-kubeconfig-mode 644

If you encounter the following...

$ sudo k3s server --write-kubeconfig-mode 644
[sudo] password for dan:
INFO[0000] Starting k3s v1.28.7+k3s1 (051b14b2)
INFO[0000] Configuring sqlite3 database connection pooling: maxIdleConns=2, maxOpenConns=0, connMaxLifetime=0s
INFO[0000] Configuring database table schema and indexes, this may take a moment...
INFO[0000] Database tables and indexes are up to date
INFO[0000] Kine available at unix://kine.sock
INFO[0000] Reconciling bootstrap data between datastore and disk
FATA[0000] starting kubernetes: preparing server: init cluster datastore and https: listen tcp :6443: bind: address already in use

...you can just stop the service with this command first:

sudo systemctl stop k3s

Solution 2: Directly provide access to the file for all users

sudo chmod 644 /etc/rancher/k3s/k3s.yaml

Your k3s cluster should now start and you will be able to get the list of pods/services confirming everything is running as expected.

kubectl get pods -n azure-iot-operations

This issue occurred every time I reset my ubuntu server's kubernetes cluster, but I will just apply that going forward to continue testing with my user and run kubectl commands without sudo ...

References:

Live Average Carbon Intensity rating with Octopus Home Mini in Home Assistant

Dan Benitah — Wed, 20 Mar 2024 00:09:20 +0000

As mentioned to Adam Jackson on Decarbonize Software 2023 the other day, here is a quick note on how to create a live consumption carbon intensity rating widget (sorry a bit of a mouthful) on your Home Assistant dashboard.

Pre-requisites:

You have an instance of Home Assistant already configured
HACS is already set up on your Home Assistant instance. Otherwise instructions can be found here: https://hacs.xyz/docs/setup/download
You are signed up to Octopus Energy provider and have requested a Octopus Home Mini - if you are not yet an Octopus Energy customer, feel free to use my referral code iron-sun-306 for £50 off your first bill

I was recently really excited to get an Octopus Home Mini. Compared to a smart meter that only reports on aggregated readings over 30 minutes blocks, the Home Mini allows for 10 seconds to 1 minute old readings which can significantly help improve smart home automation in the house. Let's face it, there is nearly no automation relevant over 30 minutes old data when it comes to energy. I have solar panels, and in a country like the UK, the sun really comes and goes and automations would need to be based on 1 to 5 minutes averages to stay relevant.

Anyway, getting up to 1 minute old consumption carbon rating can be achieve with these simple steps:

1. Install CO2 Signal Home Assistant Integration

This is available via the integration tab in Home Assistant.
CO2 Signal Home Assistant Integration

2. Install Octopus Integration and enable the Home Mini

This requires the installation of HACS first.
Octopus Home Assistant Integration

3. Set up a template that combines the values from both

Configuration

In your configuration.yaml, add the following line (to create your templates in a dedicated file - that is neater)

template: !include templates.yaml

Create that template.yaml file (alongside your configuration.yaml) and add the following content:

template:
  - sensor:
      - name: "Current hourly Electricity Carbon Emission Rating"
        unit_of_measurement: "gCO2eq/h"
        state: >
            {% set currentco2rating = states('sensor.co2_signal_co2_intensity') | float %}
            {% set liveusage = states('sensor.octopus_energy_electricity_22j0484346_1013001886662_current_demand') | float %}

            {% set totalRating = currentco2rating * liveusage/1000 %}
            {% if totalRating > 0 %}
            {{ totalRating | round(1, default=0) }}
            {%- else -%}
              0
            {%- endif %}

Note to create your own template, you can use the Template Editor under the template tab of the Developer Tools to test it.

Dashboard

You can then set up a dashboard with your current consumption or rating using the sensor card, to help you compare your consumption. The sensor card shows both the current value as well as the history over the past configured period (for me it is set to last 24h).
You could also add gauges to create some red/amber/green zones to at a glance understand how you are currently doing.

Here I am starting the battery charging when the power is at its lowest carbon intensity for the day:

This shows that when the consumption is negative, we are keeping our rating positive to a minimum of zero.

Finally this show charging the car when the power is at its lowest of the day (similar to charging the battery):

Wrap up

Adding your carbon intensity to your dashboard and combining it to your consumption makes it easy to see whether our consumption is carbon aware, i.e. whether it uses more energy cleaner, in other words, when the electricity production comes primarily from renewable energy.

EDIT 26/03/24: Thank you Ronan Glemain (@ronanglemain) for the correction tips, especially around fixing the unit of measure (from gCO2eq/kWh to gCO2eq/h) - Template has been updated though images still currently the original with the mistaken unit

Making customised chocolates using 3D printing

Dan Benitah — Tue, 19 Mar 2024 14:06:24 +0000

I was recently in search for an unusual Valentine's Day idea, came across silicon molds again and decided to give a go in the context of creating custom Valentine's Day chocolates.

First, I will say that that silicon moulds are a very impressive thing. They reproduce in details shapes, and are easy to use to recreate any object you may already have.
Second, the silicon here does not apply to resin. For I have only focused on FDM printers

Pre-requisites

Food safe silicon. I used this one
Mould frame. I recommend using this one as it offers great flexibility
Silicon mat. I used this one
Optionally you could use a heated mat like this one to accelerate your moulds solidifying. For now, I have placed mine near the radiators overnight (but might reconsider after the winter :) )

1. Create the model

3D print the desired shape: I 3D printed some custom shapes.
I also used a coin my son gave me to see how it dealt with intricate details (and it did like a chef! but more on that below)

If you are new to 3D modelling, you could start by using tinkercad.com. You could start with a basic shape like below (i.e. a shape and a message)

In this article, how about we use some code? Using OpenSCAD, you can use this gist code to generate the STL to 3D print.

2. Cast the mould

Prepare the mould frame

Start here so you can get a better idea of quantities needed to avoid wasting the silicon

Place the pieces you would like to print and assemble the mould frame around them. Make sure to arrange pieces in the space to optimise the size of the frame and overall layout (such as leaving sufficient space between pieces).
As a base at first, I used a plastic bag which leaves slight bumpy marks.

Now make sure to use the provided double sided sellotape to stick the frame, as well as each piece to the base. This will ensure the silicon does not escape outside the frame before it dries, and that the pieces will not move during the solidification process of the silicon. (The first time, some of the 3D printed pieces did move/ float, but generally did not stay stuck to the bottom and ended up with a layer of silicon in between).

Prepare the silicon

The silicon linked above is a 1:1 by volume, so you need the same amount of each liquid (part A and part B).

Make sure to mix it properly using the provided wooden piece. Stirring for some extra time, and every so often scraping the sides to ensure no liquid has been left unmixed may help get the most homogeneous substance possible.

Create the mould

Pour the silicon mixture slowly to ensure no bubbles get trapped, or the risk to move some of the pieces (although taped should be good enough)

Let it set for a few hours. When finished, gently remove the models from the silicon and let it rest for 24h (I saw the latter in the silicon's instructions and I assume this is part of keeping it food-safe, so I would encourage to do so to be extra safe).

3. Recreate your model in chocolate

Prepare the chocolate

For optimal texture results, it is advised to "temper" the chocolate. See instructions I followed here.

Pour the chocolate and let it set

By now, your chocolate is creamy.
As for the silicon, go slowly when pouring to reduce the amount of bubbles. You may even want to push a tiny bit at first into the nuts and crannies of your mould so that the details definitely come out fine (bubbles where the key features are, could really impact the look of the final result).

4. Final result

Once the chocolate has set, gently remove from the silicon, show it to get the effect it deserves and enjoy...

Here are some examples of the final result

Next steps?

So first, some lessons learnt from my first attempts include:

use sellotape to stick the models to the base
if 3D printing multiple models, it may be worth grouping as one piece (like a chocolate tablet) so everything keeps in place
sand the 3D prints for a smoother finish
use a spatula (or more generally proper utensils!)

Going forward, it would be interesting to:

find food safe silicon compatible with resin and experiment with new shapes to allow for finer details (e.g. it is hard to print a logo on a small piece that would retain the correct level of details)
try deeper chocolates shapes (the ones we are used to get from chocolate shop with more volume) as well as experiment with fillings such as praline, or crushed nuts/almonds etc...

In short, fun has only just began and please do not hesitate to share your creations below ...

Thanks to @fergusk for some of the tips mentioned above

Your organization has enabled or enforced SAML SSO ... you must re-authorize the OAuth Application `GitHub for VS Code`

Dan Benitah — Sun, 10 Mar 2024 00:53:40 +0000

I just came across the following while trying to clone a repo:

The "contoso" organization has enabled or enforced SAML SSO. To access this repository, you must re-authorize the OAuth Application GitHub for VS Code

I searched how to enable per folder authentication for git.

The easiest solution was to simply run

gh auth login

Happy cloning...

Fixing Power BI report's credentials details error in Microsoft Fabric

Dan Benitah — Mon, 05 Feb 2024 23:20:41 +0000

After publishing the Power BI report from the QueenOfTheSky demo, I encountered an issue in Fabric. Despite being directed to my Power BI workspace homepage, it wasn't clear how to proceed next.

Issue Summary

Following the steps in the build Power BI report section, I encountered an error post-publishing. The Power BI desktop app was used to open and fill in the report (.pibt), which was then published. However, upon accessing the report, an error banner indicated a connection issue and provided a link to edit settings. This link redirected me to the Power BI homepage without clear instructions on updating the connection settings.

The solution involves three seperate methods to update the connection settings for the report, identified as QueensOfTheSky_rpt:

via the setting menu
through workspace's lineage view
semantic model using the workspace list view
accessing the semantic model settings directly from the report

All methods are detailed below, with steps to guide you through updating your credentials.

How to Update Your Credentials

Update your credentials using the settings menu

From anywhere, select the Settings Menu > Power BI Settings > Semantic model tab > Select your report (QueensOfTheSky_rpt in our case) > Datasource credentials

Update your credentials using the workspace's lineage view

On your workspace page, select the ellipsis on your report's semantic model card and go to settings. You can now update your datasource credentials.

Using the list view

In your workspace, look for your semantic model (I filtered by "rpt"). Click the ellipsis and select settings.

Semantic model settings from the report

While on your report:

(1) Select the 3 dots > view Semantic model

(2) File > Settings

That's it for now

Additional guidance might be provided as Microsoft continues to refine and address these navigational challenges.

This guide aims to help you navigate and resolve connectivity issues in Power BI, ensuring a smoother experience with the QueenOfTheSky demo.

And a big THANK YOU to the contributors who created that cool demo!

EDIT late Feb : added 4th method