Offline Docker Patch Hack: Updating Jetson Cameras without Internet

Offline Docker Hacks: Patching Jetson Cameras without Internet

#

Some IT projects stick with you because they show how creative you sometimes need to be.
Recently, I had exactly such an experience: a customer with a completely isolated system, running in an environment where not even a mobile hotspot was feasible.

The challenge:

• The devices were running embedded Jetson cameras for AI vision.
• We needed to modify a few Python files and a configuration file.
• Building the images externally and importing them was logistically impractical.
• Removing the cameras for external flashing was not an option.

The only access we had was SSH to the cameras.

Solution: Patching Docker Images Directly on the Device

#

I decided on a pragmatic approach: integrate the changes directly into the existing image.

IMAGE="worker-camera"
docker tag $IMAGE:latest $IMAGE:backup
docker create --name tmp $IMAGE:latest
docker cp files_to_patch/. tmp:/app/
docker commit tmp $IMAGE:latest
docker rm tmp

Step-by-Step Explanation

#

1. Set a variable
   A small helper variable (IMAGE) saves typing effort and makes the process reproducible across multiple images.

2. Create a backup
   For safety, the current image is tagged as backup. This way, we always have a fallback.

3. Create a container (without starting it)
   Using docker create, we make a container from the image that does not run yet.

4. Copy files into the container
   The files to be patched (with the correct directory structure) are copied into the container.

5. Commit to a new image
   With docker commit, we create a new image from the container.
   Since we overwrite the latest tag, existing docker-compose files continue to work without adjustments.
   A simple docker compose up -d is enough, and the changes go live.

6. Clean up
   The temporary container tmp is removed, as it was only a means to an end.

Why This Approach Was Helpful

#

Of course, this is not the classical CI/CD workflow. In a “normal” setup, images would be built, tested, and distributed via pipelines.

But in this restrictive offline environment, the method was extremely useful:

• Fast iterations despite no internet access
• Minimal-invasive changes, without rebuilding the whole setup
• Seamless integration, since compose files remained untouched

Conclusion

#

Sometimes it’s not the big architectures but the small workarounds that keep a project running.
This approach is certainly not something you’ll need every day – but it shows how important flexibility and creativity are in IT.

👉 For me, it was a great example of how practical solutions in special cases can be more valuable than perfect theory.