Hands-on Module Implementation

Implement a shared document structure using the `automerge-py` library in Python.

Persist the Automerge document state to a local file, simulating an offline-first cache for an edge node.

Simulate a network partition between two Python clients and demonstrate automatic state merging using Automerge upon reconnection.

Use Toxiproxy to simulate high-latency and low-bandwidth conditions and analyze its impact on synchronization time.

Write a conflict resolution handler in Python that detects and logs irreconcilable data conflicts for manual review.

Integrate the synchronized Automerge state with the digital twin class from the previous module.

Deploy a local Temporal.io server and worker environment using Docker Compose.

Implement a multi-step Temporal workflow in Python to orchestrate a customs clearance process, simulating interactions with ASYCUDA.

Write unit tests for the Temporal workflow using `temporalio.testing` to verify state transitions and activity calls.

Implement the Saga pattern within the workflow using Temporal's capabilities to handle compensating transactions for a failed step.

Configure and apply a custom retry policy to an idempotent Temporal activity to handle transient network failures.

Write a Python script to start the workflow and query its status via the Temporal client.

Secure a Temporal activity by implementing a client interceptor in Python that injects an authentication token into headers.

Set up a multi-node Raft cluster in Python using the `PySyncObj` library.

Implement a replicated state machine using PySyncObj to manage a critical shared resource (e.g., gate access approval).

Write a chaos testing script in Python to randomly terminate cluster nodes and verify leader re-election and data consistency.

Design and implement a sealed-bid auction mechanism in Python for dynamic resource allocation among competing agents.

Develop a fallback procedure that triggers a manual override alert if the consensus cluster fails to reach a decision.

Secure inter-node communication in the PySyncObj cluster using TLS encryption.

Train a scikit-learn Isolation Forest model for anomaly detection on simulated logistics data.

Convert the trained scikit-learn model to ONNX format and perform inference using ONNX Runtime in a Python script.

Implement an epsilon-greedy contextual bandit algorithm in Python to solve a simplified dynamic vehicle routing problem.

Package the ONNX model and the bandit logic into a versioned artifact using MLflow for auditable deployment.

Build a lightweight Flask API to serve real-time predictions from the ONNX model.

Set up a federated learning simulation using Python with the Flower (flwr) framework and PyTorch.

Implement a Flower client that trains a simple CNN model on a local data partition, simulating an edge device.

Implement a Flower server that orchestrates rounds of training and aggregates model updates using Federated Averaging (FedAvg).

Inspect the aggregated model weights on the server to confirm that no raw client data was transferred.

Integrate a secure aggregation strategy in Flower to enhance the privacy of model updates during transmission.

Use a sentence-transformer model to generate embeddings for a corpus of logistics documents and store them in a ChromaDB vector index.

Manually implement the core RAG pipeline in Python: retrieve relevant document chunks from ChromaDB based on a user query.

Construct a context-enhanced prompt by combining the retrieved chunks with the user query for a local LLM.

Execute the prompt against a quantized LLM (e.g., Llama 2) using `llama-cpp-python` to generate an answer.

Extend the RAG pipeline to manage conversation history, enabling multi-turn dialogues about logistics operations.

Set up a local Ethereum test network using Hardhat.

Write a Solidity smart contract to create an immutable, timestamped record of a cargo's change of custody.

Create a Python script using `web3.py` to deploy the contract to the local Hardhat network.

Automate OCR data extraction from a scanned shipping manifest PDF using Python and Tesseract.

Write a function in the Python script to hash the extracted document data and record the hash on the deployed smart contract.

Install a multi-node K3s cluster on local VMs, designating one master and multiple edge worker nodes.

Containerize a Python application (e.g., the Edge AI Flask API) using Docker and push it to a local registry.

Write a Kubernetes Deployment manifest to deploy the containerized application onto the K3s cluster.

Use Kubernetes taints and tolerations to ensure specific workloads (e.g., Temporal workers) are scheduled only on designated nodes.

Create a Kubernetes Secret to securely store and mount API keys or credentials into the application pods.

Package the application's Kubernetes manifests into a Helm chart for templated, repeatable deployments.

Write a load testing script using Locust to measure the performance and scalability of the deployed Edge AI API.

Configure and run the Locust test against the K3s cluster, analyzing response times and failure rates under load.

Set up a local Prometheus server to scrape custom metrics exposed by the Python application.

Build a Grafana dashboard to visualize key system indicators, including API latency, request rate, and K3s node health.

Write an Ansible playbook to automate the zero-touch provisioning of Docker and other dependencies on a new edge node.

Implement a simulated Over-The-Air (OTA) update using Ansible to perform a rolling restart of a containerized service in K3s.