DEV Community: Madhu Kumar

Introducing Amazon Nova Act: The Future of AI-Powered Web Automation

Madhu Kumar — Fri, 04 Apr 2025 16:41:18 +0000

A New Era of AI Agents

Today (March 31, 2025), AWS introduced Amazon Nova Act, a revolutionary AI model designed to perform actions within a web browser. Alongside this, AWS is launching the Nova Act SDK, which is available as a research preview at nova.amazon.com. This SDK enables developers to experiment with the early version of Nova Act, allowing them to build AI agents capable of completing tasks in a web browser, such as submitting an out-of-office request, setting calendar holds, and even composing ‘away from office’ emails.

Beyond Traditional AI Agents

The concept of AI agents has evolved significantly. Initially, agents were designed primarily for natural language interactions and retrieval-augmented generation (RAG). However, AWS envisions agents as systems that actively perform complex digital and physical tasks on behalf of users.

While existing agents rely heavily on API integrations, Nova Act extends capabilities beyond API-covered scenarios. The dream is to create agents that can handle multi-step, complex workflows, such as organising events, managing IT tasks, and boosting productivity, without constant human supervision.

Addressing Today’s Challenges in AI Agents

One of the major limitations of current AI agents is their inability to reliably complete multi-step tasks without human intervention. Nova Act aims to solve this problem by offering a highly structured approach to workflow automation. The Nova Act SDK provides developers with reliable atomic commands, such as search, checkout, and answering on-screen queries, while allowing for detailed, customisable instructions.

Key Features of Nova Act SDK:

Reliable Atomic Commands — Execute actions like selecting dates, interacting with drop-down menus, and handling pop-ups with high accuracy.
Detailed Command Customisation — Developers can add specific instructions (e.g., “do not accept insurance upsell”) to ensure precise execution.
API and Playwright Integration — Offers a combination of API calls and direct browser manipulation via Playwright for enhanced reliability.
Python Code Integration — Allows interleaving Python scripts for testing, breakpoints, assertions, and parallelisation to optimise performance.

Best-in-Class Performance
The Nova Act model has been evaluated rigorously against industry benchmarks, achieving best-in-class performance compared to other leading models like Claude 3.7 Sonnet and OpenAI CUA. Below are the benchmark results:

These results highlight Nova Act’s superior ability to interact with web elements accurately, significantly outperforming competitors in key areas.

Headless Execution and Automation

Once configured, Nova Act agents can run autonomously without human supervision. Developers can:

Enable headless mode for seamless execution.
Convert their agent into an API for seamless product integration.
Schedule automated tasks, such as ordering dinner every Tuesday night.

Expanding AI Capabilities Beyond APIs

An exciting aspect of Nova Act is its ability to generalise across novel digital environments — even those it was not explicitly trained for. Initial results indicate promising performance in scenarios like navigating web-based games, suggesting broad adaptability beyond traditional browser interactions.

Real-World Application: Alexa+

Nova Act has already been integrated into Alexa+, where it autonomously navigates the web to complete user tasks when direct API connections are unavailable. This represents a major step toward self-directed AI agents that can function independently within complex digital ecosystems.

The Future of AI Agents

Nova Act marks the first milestone in AWS’s broader mission to develop scalable, intelligent, and reliable AI agents. AWS’s long-term vision extends beyond simple LLM fine-tuning; AWS aims to enhance AI through reinforcement learning across diverse environments, creating agents that can reliably execute complex, multi-step workflows.

Join the Innovation
AWS believes that the most valuable AI use cases have yet to be discovered. With the Nova Act SDK, AWS invites developers and innovators to explore new possibilities through rapid prototyping and iterative feedback.

The Amazon Nova Act SDK is available for research preview at nova.amazon.com. This is just the beginning of an exciting journey in AI-driven web automation. Stay tuned for more updates as AWS continues to push the boundaries of intelligent automation!

Source: https://labs.amazon.science/blog/nova-act

Think Fast, Code Faster: Local AI Development with Docker Model Runner

Madhu Kumar — Sun, 30 Mar 2025 09:38:35 +0000

Docker has taken a bold step in the AI space with its new experimental feature, Docker Model Runner, introduced in Docker Desktop for Mac 4.40+. This feature brings Large Language Model (LLM) inference directly to your machine, integrating seamlessly into Docker’s familiar ecosystem. With native GPU acceleration and the flexibility of running AI models locally, Docker Model Runner is a game-changer for developers, data scientists, and AI enthusiasts.

Let’s dive into what Docker Model Runner is, how it works, and how you can get started.

What is Docker Model Runner?

Docker Model Runner provides a Docker-native experience for running LLMs locally on Apple Silicon Macs, leveraging GPU acceleration. Unlike traditional containerised AI models, Model Runner uses a host-installed inference server (currently powered by llama.cpp) to maximise performance. For those using Windows with NVIDIA GPUs, support is expected in April 2025.

This feature allows developers to build, test, and iterate on AI applications without relying on cloud-based APIs. Whether you’re developing AI assistants or integrating AI into existing apps, Docker Model Runner has you covered.

Key Benefits of Docker Model Runner

Local AI Inference: Perform inference tasks without external API calls, ensuring data privacy.
GPU Acceleration: Harness the full power of Apple Silicon GPUs for lightning-fast model execution.
Seamless Docker Integration: Manage AI models using familiar Docker CLI commands.
Faster Iterations: Test and iterate AI applications locally with minimal latency.

Native Docker Integration with docker model CLI

Docker Desktop 4.40+ introduces the docker model CLI, making AI models first-class citizens within Docker. You can now pull, run, inspect, and manage models with commands similar to managing containers, images, and volumes.

Here are a few useful commands:

docker model --help  # List available commands
docker model list    # List the available models that can be run with the Docker Model Runner
docker model status  # Check if the Docker Model Runner is running
docker model ls      # List downloaded models
docker model pull    # Download a model
docker model run     # Run a model with the Docker Model Runner
docker model rm      # Remove a model downloaded from Docker Hub
docker model version # Show the Docker Model Runner version

How Does Docker Model Runner Work?

Unlike traditional containers, Docker Model Runner runs AI models directly on your machine. It uses llama.cpp as the inference server, bypassing the containerisation layer to minimise overhead and maximise GPU utilisation.

Key Technical Insights

Host-level Process: Models run directly on the host system using llama.cpp.
GPU Acceleration: Apple Silicon’s Metal API is used for GPU acceleration.
M*odel Loading:* Models are pulled from Docker Hub and cached locally. They are dynamically loaded into memory for efficient inference.

This architecture results in faster model execution than containerised AI solutions, reducing development time and improving the developer experience.

Who Should Use Docker Model Runner?

Docker Model Runner is designed for:

AI Developers: Build and test GenAI-powered apps locally.
Data Scientists: Efficiently run and evaluate models using local GPU resources.
Application Developers: Integrate AI capabilities into applications without leaving the Docker ecosystem.
Teams Developing AI Prototypes: Rapidly iterate on AI applications without cloud dependency.

Getting Started with Docker Model Runner

Ready to experience Docker Model Runner? Follow these steps to get started:

Step 1: Install Docker Desktop 4.40+
Ensure you have Docker Desktop 4.40 or later installed on your Apple Silicon Mac. You can download the latest version from the Docker website.

My Docker Desktop Version is "Docker Desktop 4.40.0 (186969) is currently the newest version available."

Step 2: Enable Model Runner
Open Docker Desktop.
Navigate to Settings > Features in Development.
Ensure Docker Model Runner is enabled.

For TCP support, also enable “Enable host-side TCP support”. This allows models to accept connections on port 12434 by default.

Step 3: Verify Installation
Run the following command to check if Model Runner is active:

command: docker model status
# Output: Docker Model Runner is running

~/Documents/docker  docker model status
Docker Model Runner is running

Step 4: Download a Model

Download a model from Docker Hub using the following command:

command: docker model pull ai/llama3.2:1B-Q8_0

 ~/Documents/docker  docker model pull ai/llama3.2:1B-Q8_0
Downloaded: 1259.13 MB
Model ai/llama3.2:1B-Q8_0 pulled successfully

You can choose from a range of models, including:

ai/llama3.2
ai/gemma3
ai/qwen2.5
ai/mistral
Refer here for more models: https://hub.docker.com/u/ai

Step 5: Run a Model
Send a simple input to your model using:

command: docker model run ai/llama3.2:1B-Q8_0 "Hi, how are you?"
# example Output: Hello! How can I help you today?

 ~/Documents/docker  docker model run ai/llama3.2:1B-Q8_0 "Hi, how are you?"
I'm just a computer program, so I don't have emotions or feelings like humans do, but thanks for asking! How can I assist you today?

You can also run models in interactive mode:

command: docker model run ai/llama3.2:1B-Q8_0
> Why is the sky blue?


 ~/Documents/docker  docker model run ai/llama3.2:1B-Q8_0
> Why is the sky blue?
Interactive chat mode started. Type '/bye' to exit.
> Why is the sky blue?
The sky appears blue because of a phenomenon called Rayleigh scattering, named after the British physicist Lord Rayleigh, who first described it in the late 19th century.

Here's what happens:

**The Short Answer:** The shorter (blue) wavelengths of light are scattered more than the longer (red) wavelengths, giving the sky its blue appearance.

**The Longer Answer:**

When sunlight enters Earth's atmosphere, it encounters tiny molecules of gases such as nitrogen (N2) and oxygen (O2). These molecules are much smaller than the wavelength of light, and they scatter the light in all directions. This scattering effect is more pronounced for shorter wavelengths, like blue and violet, due to the smaller particle sizes.

There are two types of scattering that occur in the atmosphere:

1. **Rayleigh scattering**: This type of scattering occurs when light is scattered by small particles, like the molecules of gases in the atmosphere. The shorter wavelengths (like blue and violet) are scattered more than the longer wavelengths (like red and orange). This is because the smaller particles are more effective at scattering the shorter wavelengths.
2. **Mie scattering**: This type of scattering occurs when light is scattered by larger particles, like dust and pollen. The longer wavelengths (like red and orange) are scattered less than the shorter wavelengths.

**Why the blue color dominates:**

As sunlight enters the atmosphere, it encounters more Rayleigh scattering than Mie scattering. The scattered blue light is then reflected back into our eyes, creating the illusion of a blue sky. The longer wavelengths, like red and orange, are scattered in all directions and are not reflected back, making them appear more red.

**Additional factors:**

Other factors can also influence the color of the sky, such as:

* **Dust and pollution**: Tiny particles in the atmosphere can scatter light in different ways, changing the color of the sky.
* **Clouds**: Clouds can reflect or absorb light, changing the color of the sky.
* **Time of day and year**: The angle of the sun and the position of the Earth in its orbit can also affect the color of the sky.

Now, the next time you gaze up at the sky, remember that the blue color is a result of a fascinating combination of Rayleigh and Mie scattering!
> /bye
Chat session ended.

Step 6: Remove a Model

When you no longer need a model, remove it using:

command: docker model rm ai/llama3.2:1B-Q8_0

 ~/Doc/docker  docker model rm ai/llama3.2:1B-Q8_0
Model ai/llama3.2:1B-Q8_0 removed successfully

Using Model Runner in Your Application

You can integrate Model Runner into your AI applications using its OpenAI-compatible endpoints. Follow these steps to build a GenAI application:

Step 1: Download the Model

docker model pull ai/llama3.2:1B-Q8_0

Step 2: Clone the Repository from the official Docker GitHub

https://github.com/docker/hello-genai

git clone https://github.com/docker/hello-genai
cd hello-genai

 ~/Documents/docker  git clone https://github.com/docker/hello-genai
cd hello-genai
Cloning into 'hello-genai'...
remote: Enumerating objects: 31, done.
remote: Counting objects: 100% (31/31), done.
remote: Compressing objects: 100% (26/26), done.
remote: Total 31 (delta 4), reused 27 (delta 2), pack-reused 0 (from 0)
Receiving objects: 100% (31/31), 15.49 KiB | 7.75 MiB/s, done.
Resolving deltas: 100% (4/4), done.

 ~/Documents/docker/hello-genai  main  ll
total 56
-rw-r--r--  1 macpro  staff   413B 29 Mar 18:15 Dockerfile
-rw-r--r--  1 macpro  staff    11K 29 Mar 18:15 LICENSE
-rw-r--r--  1 macpro  staff   1.1K 29 Mar 18:15 README.md
-rw-r--r--  1 macpro  staff   800B 29 Mar 18:15 docker-compose.yml
drwxr-xr-x  7 macpro  staff   224B 29 Mar 18:15 go-genai
drwxr-xr-x  6 macpro  staff   192B 29 Mar 18:15 node-genai
drwxr-xr-x  7 macpro  staff   224B 29 Mar 18:15 py-genai
-rwxr-xr-x  1 macpro  staff   517B 29 Mar 18:15 run.sh

Step 3: Configure the Backend: Set the environment variables

BASE_URL=http://model-runner.docker.internal/engines/llama.cpp/v1/
MODEL=ai/llama3.2:1B-Q8_0

~/Documents/docker/hello-genai BASE_URL=http://model-runner.docker.internal/engines/llama.cpp/v1/
MODEL=ai/llama3.2:1B-Q8_0

Step 4: Start the Application

command: docker compose up -d


 ~/Documents/docker/hello-genai  main  docker compose up -d

Compose now can delegate build to bake for better performances
Just set COMPOSE_BAKE=true
[+] Building 12.1s (47/47) FINISHED                                                                    docker:desktop-linux
 => [node-genai internal] load build definition from Dockerfile                                                        0.0s
 => => transferring dockerfile: 329B                                                                                   0.0s
 => [go-genai internal] load build definition from Dockerfile                                                          0.0s
 => => transferring dockerfile: 706B                                                                                   0.0s
 => [python-genai internal] load build definition from Dockerfile                                                      0.0s
 => => transferring dockerfile: 421B                                                                                   0.0s
 => [go-genai internal] load metadata for docker.io/library/alpine:latest                                              1.3s
 => [go-genai internal] load metadata for docker.io/library/golang:1.21-alpine                                         1.3s
 => [python-genai internal] load metadata for docker.io/library/python:3.11-slim                                       1.3s
 => [node-genai internal] load metadata for docker.io/library/node:20-alpine                                           1.3s
 => [go-genai auth] library/alpine:pull token for registry-1.docker.io                                                 0.0s
 => [go-genai auth] library/golang:pull token for registry-1.docker.io                                                 0.0s
 => [python-genai auth] library/python:pull token for registry-1.docker.io                                             0.0s
 => [node-genai auth] library/node:pull token for registry-1.docker.io                                                 0.0s
 => [python-genai internal] load .dockerignore                                                                         0.0s
 => => transferring context: 271B                                                                                      0.0s
 => [go-genai internal] load .dockerignore                                                                             0.0s
 => => transferring context: 239B                                                                                      0.0s
 => [node-genai internal] load .dockerignore                                                                           0.0s
 => => transferring context: 2B                                                                                        0.0s
 => [python-genai 1/7] FROM docker.io/library/python:3.11-slim@sha256:7029b00486ac40bed03e36775b864d3f3d39dcbdf19cd45  3.5s
 => => resolve docker.io/library/python:3.11-slim@sha256:7029b00486ac40bed03e36775b864d3f3d39dcbdf19cd45e6a52d541e6c1  0.0s
 => => sha256:7029b00486ac40bed03e36775b864d3f3d39dcbdf19cd45e6a52d541e6c178f0 9.13kB / 9.13kB                         0.0s
 => => sha256:b302c93452310b37ffcd9436bbfdb0a3d5b60b19dd3c86badb83b66d20c38ca4 1.75kB / 1.75kB                         0.0s
 => => sha256:f4c484c0338e730d3e53480fb48088dc3b3a016858b94559ce7087577ae3b204 5.31kB / 5.31kB                         0.0s
 => => sha256:d9b6365477446a79987b20560ae52637be6f54d6d2f801e16aaa0ca25dd0964b 28.04MB / 28.04MB                       1.3s
 => => sha256:3f529d1f5c642f942a2f18a72c6b14f378767cdf3f66131f04497701e8361712 3.33MB / 3.33MB                         1.0s
 => => sha256:18513d00e8c20c79d50d6646c0f48fe4349ead2882c93b54d94bb54917adbd90 16.13MB / 16.13MB                       1.4s
 => => sha256:82a6dca8a532d0999dead89c78b567015ba2ee32175dea32fefbecf004cad9d6 249B / 249B                             1.2s
 => => extracting sha256:d9b6365477446a79987b20560ae52637be6f54d6d2f801e16aaa0ca25dd0964b                              1.3s
 => => extracting sha256:3f529d1f5c642f942a2f18a72c6b14f378767cdf3f66131f04497701e8361712                              0.1s
 => => extracting sha256:18513d00e8c20c79d50d6646c0f48fe4349ead2882c93b54d94bb54917adbd90                              0.6s
 => => extracting sha256:82a6dca8a532d0999dead89c78b567015ba2ee32175dea32fefbecf004cad9d6                              0.0s
 => [python-genai internal] load build context                                                                         0.0s
 => => transferring context: 9.84kB                                                                                    0.0s
 => [go-genai builder 1/7] FROM docker.io/library/golang:1.21-alpine@sha256:2414035b086e3c42b99654c8b26e6f5b1b1598080  4.7s
 => => resolve docker.io/library/golang:1.21-alpine@sha256:2414035b086e3c42b99654c8b26e6f5b1b1598080d65fd03c7f499552f  0.0s
 => => sha256:2414035b086e3c42b99654c8b26e6f5b1b1598080d65fd03c7f499552ff4dc94 10.30kB / 10.30kB                       0.0s
 => => sha256:5bc6d0431a4fdc57fb24d437c177c5e02fde1d0585eeb4c5d483c1b65aebfb00 1.92kB / 1.92kB                         0.0s
 => => sha256:2bbe4e7e4d4e0f6f1b6c7192f01b9c7099e921b9fe8eae0c5c939a1d257f7e81 2.10kB / 2.10kB                         0.0s
 => => sha256:690e87867337b8441990047e169b892933e9006bdbcbed52ab7a356945477a4d 4.09MB / 4.09MB                         0.2s
 => => sha256:171883aaf475f5dea5723bb43248d9cf3f3c3a7cf5927947a8bed4836bbccb62 293.51kB / 293.51kB                     0.2s
 => => sha256:2a6022646f09ee78a83ef4abd0f5af04071b6563cf16a18e00fb2dcfe63ca0a3 64.11MB / 64.11MB                       1.0s
 => => extracting sha256:690e87867337b8441990047e169b892933e9006bdbcbed52ab7a356945477a4d                              0.1s
 => => sha256:e495e1face5cc12777f452389e1da15202c37ec00ba024f12f841b5c90a47057 127B / 127B                             0.5s
 => => sha256:4f4fb700ef54461cfa02571ae0db9a0dc1e0cdb5577484a6d75e68dc38e8acc1 32B / 32B                               0.5s
 => => extracting sha256:171883aaf475f5dea5723bb43248d9cf3f3c3a7cf5927947a8bed4836bbccb62                              0.0s
 => => extracting sha256:2a6022646f09ee78a83ef4abd0f5af04071b6563cf16a18e00fb2dcfe63ca0a3                              3.6s
 => => extracting sha256:e495e1face5cc12777f452389e1da15202c37ec00ba024f12f841b5c90a47057                              0.0s
 => => extracting sha256:4f4fb700ef54461cfa02571ae0db9a0dc1e0cdb5577484a6d75e68dc38e8acc1                              0.0s
 => [go-genai stage-1 1/4] FROM docker.io/library/alpine:latest@sha256:a8560b36e8b8210634f77d9f7f9efd7ffa463e380b75e2  1.7s
 => => resolve docker.io/library/alpine:latest@sha256:a8560b36e8b8210634f77d9f7f9efd7ffa463e380b75e2e74aff4511df3ef88  0.0s
 => => sha256:a8560b36e8b8210634f77d9f7f9efd7ffa463e380b75e2e74aff4511df3ef88c 9.22kB / 9.22kB                         0.0s
 => => sha256:757d680068d77be46fd1ea20fb21db16f150468c5e7079a08a2e4705aec096ac 1.02kB / 1.02kB                         0.0s
 => => sha256:8d591b0b7dea080ea3be9e12ae563eebf9869168ffced1cb25b2470a3d9fe15e 597B / 597B                             0.0s
 => => sha256:6e771e15690e2fabf2332d3a3b744495411d6e0b00b2aea64419b58b0066cf81 3.99MB / 3.99MB                         1.5s
 => => extracting sha256:6e771e15690e2fabf2332d3a3b744495411d6e0b00b2aea64419b58b0066cf81                              0.1s
 => [go-genai internal] load build context                                                                             0.0s
 => => transferring context: 12.11kB                                                                                   0.0s
 => [node-genai 1/6] FROM docker.io/library/node:20-alpine@sha256:8bda036ddd59ea51a23bc1a1035d3b5c614e72c01366d989f41  3.3s
 => => resolve docker.io/library/node:20-alpine@sha256:8bda036ddd59ea51a23bc1a1035d3b5c614e72c01366d989f4120e8adca196  0.0s
 => => sha256:8bda036ddd59ea51a23bc1a1035d3b5c614e72c01366d989f4120e8adca196d4 7.67kB / 7.67kB                         0.0s
 => => sha256:646bc11400802534d70bc576fc9704bb6409e0ed802658a8e785472d160c38d3 1.72kB / 1.72kB                         0.0s
 => => sha256:f06038a15a690bf7aa19f84b6d7bf2646640654b47fd5d2dd8fca56ff81f0789 6.20kB / 6.20kB                         0.0s
 => => sha256:6e771e15690e2fabf2332d3a3b744495411d6e0b00b2aea64419b58b0066cf81 3.99MB / 3.99MB                         1.5s
 => => sha256:8bfaf621f0ce4e4ddf5efac2af68a506ee03c6cb9151dd7f9b2b8937b3cfdfb5 1.26MB / 1.26MB                         1.7s
 => => sha256:0e3e948a6346a46c6ad228463eb896bd63a271b9b122fc90d39a8702b2349746 42.63MB / 42.63MB                       2.0s
 => => extracting sha256:6e771e15690e2fabf2332d3a3b744495411d6e0b00b2aea64419b58b0066cf81                              0.1s
 => => sha256:8d73ebbcecf2389cf3461a46c9a11972293f334e5093233adb4f1c65ef91e4e0 444B / 444B                             1.7s
 => => extracting sha256:0e3e948a6346a46c6ad228463eb896bd63a271b9b122fc90d39a8702b2349746                              1.1s
 => => extracting sha256:8bfaf621f0ce4e4ddf5efac2af68a506ee03c6cb9151dd7f9b2b8937b3cfdfb5                              0.0s
 => => extracting sha256:8d73ebbcecf2389cf3461a46c9a11972293f334e5093233adb4f1c65ef91e4e0                              0.0s
 => [node-genai internal] load build context                                                                           0.0s
 => => transferring context: 10.20kB                                                                                   0.0s
 => [go-genai stage-1 2/4] RUN apk --no-cache add ca-certificates                                                      0.8s
 => [go-genai stage-1 3/4] WORKDIR /root/                                                                              0.1s
 => [node-genai 2/6] WORKDIR /app                                                                                      0.1s
 => [node-genai 3/6] COPY package*.json ./                                                                             0.0s
 => [node-genai 4/6] RUN npm install                                                                                   2.4s
 => [python-genai 2/7] WORKDIR /app                                                                                    0.0s
 => [python-genai 3/7] COPY requirements.txt .                                                                         0.0s
 => [python-genai 4/7] RUN pip install --no-cache-dir -r requirements.txt                                              2.9s
 => [go-genai builder 2/7] RUN apk add --no-cache git                                                                  0.8s
 => [go-genai builder 3/7] WORKDIR /app                                                                                0.0s
 => [go-genai builder 4/7] COPY go.mod ./                                                                              0.0s
 => [go-genai builder 5/7] RUN go mod download                                                                         0.1s
 => [go-genai builder 6/7] COPY . .                                                                                    0.0s
 => [go-genai builder 7/7] RUN CGO_ENABLED=0 GOOS=linux go build -o /go-genai                                          4.7s
 => [node-genai 5/6] COPY . .                                                                                          0.0s
 => [node-genai 6/6] RUN mkdir -p views                                                                                0.2s
 => [node-genai] exporting to image                                                                                    0.1s
 => => exporting layers                                                                                                0.1s
 => => writing image sha256:05338f427d2bc2449ac87eea0888961c68a93df74ca11b535b1f292a7179b098                           0.0s
 => => naming to docker.io/library/hello-genai-node-genai                                                              0.0s
 => [node-genai] resolving provenance for metadata file                                                                0.0s
 => [python-genai 5/7] COPY . .                                                                                        0.0s
 => [python-genai 6/7] RUN mkdir -p templates                                                                          0.1s
 => [python-genai 7/7] COPY templates/index.html templates/                                                            0.0s
 => [python-genai] exporting to image                                                                                  0.1s
 => => exporting layers                                                                                                0.1s
 => => writing image sha256:ee3a3acc92d2574fd1ce81ad8e167e2bedb32202b5cbf3cd0e80927797a37893                           0.0s
 => => naming to docker.io/library/hello-genai-python-genai                                                            0.0s
 => [python-genai] resolving provenance for metadata file                                                              0.0s
 => [go-genai stage-1 4/4] COPY --from=builder /go-genai .                                                             0.0s
 => [go-genai] exporting to image                                                                                      0.1s
 => => exporting layers                                                                                                0.1s
 => => writing image sha256:7ce7c4d915612db46ca4ee65dc53499a69509a80d8ecbb372366c58a1f6be533                           0.0s
 => => naming to docker.io/library/hello-genai-go-genai                                                                0.0s
 => [go-genai] resolving provenance for metadata file                                                                  0.0s
[+] Running 7/7
 ✔ go-genai                              Built                                                                         0.0s
 ✔ node-genai                            Built                                                                         0.0s
 ✔ python-genai                          Built                                                                         0.0s
 ✔ Network hello-genai_default           Created                                                                       0.0s
 ✔ Container hello-genai-python-genai-1  Started                                                                       0.4s
 ✔ Container hello-genai-node-genai-1    Started                                                                       0.4s
 ✔ Container hello-genai-go-genai-1      Started

Access the App: Visit http://localhost:8081 to interact with your AI-powered application.

Step 5: Chat with the Application

Step 6: Stop the Application

 ~/Documents/docker/hello-genai  main  docker-compose down                                               ok  14s  18:17:53
[+] Running 4/4
 ✔ Container hello-genai-go-genai-1      Removed                                                                       0.2s
 ✔ Container hello-genai-python-genai-1  Removed                                                                      10.3s
 ✔ Container hello-genai-node-genai-1    Removed                                                                      10.3s
 ✔ Network hello-genai_default           Removed

Conclusion

Docker Model Runner makes AI development faster, simpler, and more efficient by bringing AI inference to your local machine. With powerful GPU acceleration and seamless Docker integration, you can build and test GenAI applications with minimal friction.

Whether you’re an AI researcher, developer, or enthusiast, Docker Model Runner is an invaluable addition to your AI toolkit. Give it a try and experience the future of local AI development.

Stay tuned for upcoming updates, including Windows support and additional model integrations!

Happy coding!

The Evolution of Computing: From Vacuum Tubes to the Groundbreaking Majorana Chip

Madhu Kumar — Mon, 24 Feb 2025 08:11:36 +0000

The Evolution of Computing: From Vacuum Tubes to Majorana Qubits

1. The Age of Vacuum Tubes (1904–1950s)

A vacuum tube is an electronic device that uses a vacuum as an insulator to shield against electric currents. It works by creating a vacuum inside the tube, which means there is no air or other material inside that could conduct electricity.

The journey of modern computing began with vacuum tubes, which were large, fragile, and consumed immense power.

Key Milestones:

1904: John Ambrose Fleming invented the first vacuum tube, the thermionic diode.

1920s — 1930s: The development of triodes (which could amplify signals) revolutionised early electronics.

1940s: The first general-purpose electronic computers, such as the ENIAC (1945), used thousands of vacuum tubes.

Challenges: Vacuum tubes were bulky, overheated easily, and were prone to failure.

2. The Rise of Transistors (1947–1960s)

To overcome the limitations of vacuum tubes, the transistor was invented, marking a new era of miniaturisation and efficiency.

A transistor is a miniature semiconductor that regulates or controls current or voltage flow in addition to amplifying and generating these electrical signals and acting as a switch or gate for them.

Key Milestones:

1947: John Bardeen, Walter Brattain, and William Shockley at Bell Labs invented the first transistor.

1950s: Transistors started replacing vacuum tubes in computing devices.

1958: Jack Kilby and Robert Noyce developed the first integrated circuit (IC), paving the way for further miniaturisation.

Impact: Computers became smaller, more efficient, and more reliable.

3. The Integrated Circuit Revolution (1960s — 1970s)

An integrated circuit (IC), is an assembly of electronic components, fabricated as a single unit, in which miniaturised active devices (e.g., transistors and diodes) and passive devices (e.g., capacitors and resistors) and their interconnections are built up on a thin substrate of semiconductor material (typically silicon).

The development of ICs enabled the creation of microprocessors, leading to the first personal computers.

Key Milestones:

1965: Gordon Moore proposed Moore’s Law, predicting the exponential growth of computing power.

1971: Intel released the first commercial microprocessor, the Intel 4004.

Late 1970s: The rise of personal computing with Apple, IBM, and other companies.

Impact: Computing power became accessible to individuals and businesses worldwide.

4. The Silicon Era and Moore’s Law Expansion (1980s — 2000s)

With continued advances in silicon-based semiconductors, computing has become faster, cheaper, and more ubiquitous.

Key Milestones:

1980s — 1990s: Rise of microcomputers, graphical user interfaces (GUI), and the internet revolution.

2000s: Multi-core processors and parallel computing became mainstream.

Challenges: Moore’s Law showed signs of slowing as transistors approached atomic-scale limits.

5. The Dawn of Quantum Computing (1990s — Present)

With classical computing facing physical limitations, quantum mechanics opened new possibilities.

Key Milestones:

1994: Peter Shor developed Shor’s algorithm, demonstrating quantum computing’s potential to break RSA encryption.

1998: First experimental demonstration of quantum computing with 2 qubits.

2019: Google claimed quantum supremacy with Sycamore, performing calculations infeasible for classical computers.

Challenges: Quantum decoherence, error correction, and hardware stability remain obstacles.

6. Majorana Qubits: The Future of Quantum Computing

One of the most promising approaches in quantum computing involves Majorana fermions, exotic particles that can enable topological qubits.

Key Milestones:

1937: Ettore Majorana proposed the existence of Majorana fermions.

2012: Microsoft and researchers discovered experimental signatures of Majorana fermions in superconducting nanowires.

2025: In a groundbreaking advancement, Microsoft has unveiled the Majorana 1 chip, a quantum processor poised to revolutionise the field of quantum computing. This innovation leverages topological qubits derived from Majorana fermions, aiming to overcome longstanding challenges in qubit stability and scalability.

Introducing the Majorana 1 Chip

The Majorana 1 chip represents a significant milestone in this research trajectory. Utilising a novel Topological Core architecture, this processor is designed to house up to one million qubits on a single, palm-sized chip. This scalability is crucial for tackling complex, real-world problems that are beyond the capabilities of classical computers.

The Science Behind Topological Qubits

Topological qubits gain their resilience from the unique properties of Majorana fermions. By manipulating these particles through processes known as “braiding,” quantum information can be encoded in a manner that is inherently resistant to errors caused by local perturbations. This method stands in contrast to traditional qubits, which require extensive error correction protocols.

Implications and Future Prospects

The development of the Majorana 1 chip is poised to accelerate the realisation of practical quantum computing applications. Potential impacts span various industries, including cryptography, material science, and complex system modelling. While challenges remain in scaling and integrating this technology, Microsoft’s breakthrough offers a promising pathway toward quantum systems capable of addressing problems once deemed intractable.

Conclusion

From vacuum tubes to transistors, from silicon chips to quantum bits, computing has undergone a massive transformation. The next era, powered by Majorana qubits, could unlock unprecedented computational capabilities — ushering in a new age of quantum supremacy and secure cryptographic systems.

What’s next? The race for practical quantum computing is on, and the future is closer than ever.

Self-Hosting AI Workflows on Mac: DeepSeek-R1 + Ollama + n8n powered by Docker

Madhu Kumar — Thu, 13 Feb 2025 08:28:27 +0000

I’ll walk through the process of setting up a local environment on a MacBook Pro M3 (18GB) to test the DeepSeek model using Ollama, n8n, and Docker via Docker Desktop. This setup is suitable ONLY for performing PoCs and development environments.

Prerequisites

Before we begin, make sure you have the following (or similar setup):

MacBook Pro M3 with 18GB RAM
Docker installed (via Docker desktop - https://www.docker.com/products/docker-desktop)
Ollama installed (https://ollama.com)
n8n installed (https://docs.n8n.io/hosting — for automating workflows, we’ll use this to test DeepSeek)

Setting Up DeepSeek-R1 with Ollama

DeepSeek-R1 is a powerful open-source AI model optimized for complex reasoning, coding, mathematics, and problem-solving. Running it locally ensures privacy, performance, and customization.

Let’s dive into the steps!
Step:1:
1: Install n8n Using Docker Compose
We’ll use Docker Compose to spin up n8n.

Create a folder for the n8n setup:

mkdir ~/n8n-docker && cd ~/n8n-docker

2. Create a simple docker-compose.yml file for n8n:

version: '3.9'

services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    ports:
      - "5678:5678"
    volumes:
      - ./n8n_data:/home/node/.n8n # Persistent storage for workflows and data
    restart: unless-stopped

3. Start the n8n service:

docker-compose up -d

4. Open n8n in your browser: http://localhost:5678. Setup an owner account and Log in using the credentials.

You can request a free n8n license key (emailed to you) to unlock selected paid features on your community edition of n8n. You can enter and activate your key as shown below.

Step 2: Install Ollama

 ~/Doc/AI-Projects  brew install ollama                     
Warning: ollama 0.5.7 is already installed and up-to-date.
To reinstall 0.5.7, run:
  brew reinstall ollama

Step 3: Download the DeepSeek 7B model using Ollama:

~/Doc/AI-Projects  ollama run deepseek-r1:7b                                    
pulling manifest
pulling 96c415656d37... 100% ▕████████████████▏ 4.7 GB
pulling 369ca498f347... 100% ▕████████████████▏  387 B
pulling 6e4c38e1172f... 100% ▕████████████████▏ 1.1 KB
pulling f4d24e9138dd... 100% ▕████████████████▏  148 B
pulling 40fb844194b2... 100% ▕████████████████▏  487 B
verifying sha256 digest
writing manifest
success
>>> /bye

 ~/Doc/AI-Projects  ollama list                                  
NAME              ID              SIZE      MODIFIED
deepseek-r1:7b    0a8c26691023    4.7 GB    26 hours ago

Step 4: Integrate DeepSeek with n8n

Let’s set up a workflow in n8n to interact with the DeepSeek model.

4.1: Create Chat Trigger, Basic LLM Chain and Ollama Chat Model nodes

4.2: Configure Ollama Chat Model and test the connectivity

Double-click on the Ollama Chat Model node and configure the Ollama Base URL.

Instead of using localhost, set it to host.docker.internal with the appropriate Ollama port number (11434). Using localhost will result in a connection refused error, as Docker containers require host.docker.internal to access services running on the host machine.

Once the connection is tested successfully, select the Deepseek model we have downloaded deepseek-r1:7b under parameters.

Step 5: Test DeepSeek 7B Model

Now that everything is set up:

Test more complex queries using the DeepSeek 7B model.
Create workflows in n8n to automate LLM-based tasks, such as summarisation, Q&A, or sentiment analysis.

Simple test:

Madhu: who are you

<think>

</think>

Greetings! I'm DeepSeek-R1, an artificial intelligence assistant created by DeepSeek. I'm at your service and would be delighted to assist you with any inquiries or tasks you may have.



Madhu: create terraform code to deploy eks cluster in aws


<think> Okay, I need to create a Terraform code to deploy an EKS cluster on AWS. Let me think about how to approach this.

First, I should outline the main components needed for deploying EKS using AWS. The key parts are the master node and worker nodes. So, I'll probably use Terraform modules like ec2 for general EC2 setup, ebs for adding storage, rds for the database, elb for the load balancer, and autoscaling groups to manage scaling.

I remember that EKS requires a cluster name which should be unique, so using a random string would make sense. I'll include a list of required modules at the top of my file to ensure they're loaded first.

Next, I need to define resources for each node type. The master will have an instance type like t2.micro, and workers can use r5.micro with a higher vpc_id for better performance since workers are in the same subnet as the master.

For storage, using ProvisionedS3Bucket makes sense because it's easy to manage and provides persistent storage. I'll set up both a default bucket and maybe an object store for EKS secrets or logs.

The database should be RDS, so I'll configure a MySQL or PostgreSQL instance in the same subnet as the master for consistency.

The load balancer is crucial for traffic distribution. I'll create an ELB that directs traffic to the EKS cluster nodes. The LB needs to be in the same VPC and Security Group as the master to ensure all nodes are reachable.

Autoscaling groups will help manage scaling based on load and temperature. I'll set up two groups, one for scaling out and another for scaling back, with appropriate policies so they don't interfere with each other.

I should also include environment variables in the Infrastructure Block for easy deployment from different environments like dev, staging, or prod.

It's important to note that EKS requires specific IAM roles for each resource. I might need to create these roles in a separate Terraform file or handle them within this code using assume_iam_role statements.

Wait, does the worker node need its own storage? Maybe using an S3 bucket per node isn't efficient, so perhaps using a shared storage solution like EFS or a persistent volume would be better. Or maybe I can use the same storage as the master for simplicity since they're in the same subnet.

I'm also thinking about security groups. They need to allow SSH access and connect all nodes (including ELB) to each other. So, I'll define a security group that includes both nodes and the ELB.

Another consideration is network interfaces. Each node's VPC ID should match so they're in the same subnet for communication.

I should make sure all necessary modules are imported at the top of the file, like module 'ec2', 'ebs', etc., to avoid any undefined variable errors.

Also, I need to define a list of parameter values that can be overridden or changed between environments. This way, each deployment environment can have its own configuration without rebuilding the entire code.

Putting it all together, I'll structure the code with modules at the top, then define variables and resources in order. Each node type (master and worker) will be defined using their respective modules. The EKS cluster will include all these components plus the autoscaling groups for scaling management.

I should also ensure that the output includes all necessary information like cluster name, master IP, etc., so users can easily deploy without manual input.

Finally, I'll include a note about how to apply the changes and test the deployment, as well as mentioning the IAM roles required. This will help the user understand what steps to take next after running the Terraform code. </think>

To deploy an EKS cluster using Terraform on AWS, you can follow these steps with the provided code:

Define Required Modules: Ensure all necessary modules are imported first.

Set Up Variables: Create a variable list for deployment configuration.

Define Resources:

Master Node
Worker Nodes
Storage Solutions (S3, RDS)
Load Balancer
Autoscaling Groups
Create Infrastructure Block: Manage environment-specific configurations.

Define Tags and Output: Include useful metadata for deployment.

Write Terraform Code:

# Top of the file with required modules
module "ec2"
  define "parameters" = [
    "region",
    "cluster_name",
    "vpc_id",
    "security_group",
    "KeyName", 
    "efs_size",
    "s3_bucket_name",
    "rds_db_name",
    "master BootTime",
    "worker BootTime"
  ]

# Infrastructure configuration

module = "ec2"

var Parameters = parameters()

# Define CloudFormation stack variables
var Region = Parameters.region
var ClusterName = Parameters.cluster_name
var VpcId = Parameters.vpc_id
var SecurityGroup = Parameters.security_group
var KeyName = Parameters.KeyName
var EfSSize = Parameters.efs_size
var S3BucketName = Parameters.s3_bucket_name
var RdsDbName = Parameters.rds_db_name

var Master = "t2.micro"
var Worker = "r5.micro"

# Define storage solutions
var StorageSolution = {
  type: "provisioned_s3_bucket",
  bucket_name: S3BucketName,
  region: Region
}

var EksClusterStorage = {
  type: "efs",
  root_size_in_gigabytes: EfSSize,
  region: Region
}

# Define database solution
var Rds = {
  type: "rds",
  engine: "mysql",
  name: RdsDbName,
  region: Region,
  key_name: KeyName,
  storage_type: "persistent",
  availability_zone: VpcId[0].Availability_Zone
}

# Define load balancer configuration
var LoadBalancer = {
  type: "elastic_load_balancer",
  name: ClusterName LoadBalancer,
  region: Region,
  load_balancer subnet_id: VpcId[0].Subnet_id,
  security_groups: [SecurityGroup],
  inboundrules: [{
    destination_port: 80,
    protocol: "TCP"
  }]
}

# Define autoscaling groups
var AutoscalingOut = {
  type: "autoscaling",
  scaling_out enabled: true,
  min_count: 2,
  max_count: 6,
  policy: { target_arn: "arn:aws:elasticloadbalancing:Region::app:elb/LoadBalancer/Status" }
}

var AutoscalingIn = {
  type: "autoscaling",
  scaling_in enabled: true,
  min_count: 2,
  max_count: 6,
  policy: { target_arn: "arn:aws:elasticloadbalancing:Region::app:elb/LoadBalancer/Status" }
}

# Apply changes
apply {
  # Define the master node
  ec2.master(InstanceType = Master, KeyName = KeyName, AvailabilityZone = VpcId[0].Availability_Zone,
    SecurityGroupIds = [SecurityGroup], SubnetId = VpcId[0].Subnet_id, 
    Storage = StorageSolution, EnableNetworking: true)

# Define the worker nodes
  map "workers" {
    Worker,
    KeyName = KeyName,
    AvailabilityZone = VpcId[0].Availability_Zone,
    SecurityGroupIds = [SecurityGroup],
    SubnetId = VpcId[0].Subnet_id,
    Storage = StorageSolution,
    EnableNetworking: true
  }

# Define the EKS cluster with master and worker nodes
  eks(Storage = EksClusterStorage, LoadBalancer = LoadBalancer, AutoscalingGroups = [AutoscalingOut, AutoscalingIn])

# Infrastructure blocks
  infrastructureBlock "parameters" {
    parameters
  }

  infrastructureBlock "environment" {
    environment = Parameters.environment
  }
}

# Output information for deployment confirmation
output "cluster_name" = ClusterName
output "master_ip" = ec2.master.ip_address
output "workers_count" = (number of workers)
This code provides a comprehensive configuration to deploy an EKS cluster using Terraform on AWS. It includes:

Master Node: Uses a T2.micro instance with RDS for storage and networking.
Worker Nodes: Utilizes R5.micro instances, providing better performance compared to master nodes.
Storage: Both S3 and EFS are configured to provide redundancy and in-cluster storage solutions.
Load Balancer: Ensures traffic is distributed efficiently among all cluster nodes.
Autoscaling Groups: Manages scaling based on load and temperature, with two groups for scaling out/in.
To use this code:

Ensure Terraform Installation: Confirm that Terraform is installed and configured correctly.
Define Parameters: Create a YAML configuration file for your specific environment (dev, staging, prod).
Apply Changes: Use terraform apply to deploy the EKS cluster based on your configurations.
Note: The code assumes you have IAM roles set up with appropriate permissions for EKS operations, including RDS, S3, and ELB access. Ensure these roles are available before running the deployment.

Conclusion

The DeepSeek R1 LLM stands out for its ability to run locally within a Docker-powered environment, ensuring a privacy-first, efficient, and cost-effective alternative to cloud-based LLMs. By leveraging Docker alongside Ollama and n8n, DeepSeek offers a seamless workflow for testing and automation without the need for extensive infrastructure or internet connectivity.

Feel free to experiment with different workflows and use cases!

Learning continues.!

The AI Game-Changer: How to Deploy DeepSeek-R1 Locally on a MacBook Pro M3

Madhu Kumar — Sun, 26 Jan 2025 21:43:50 +0000

I’ve just come across DeepSeek R1, and I’m absolutely excited about it! For those who aren’t familiar, it’s a groundbreaking new open-source AI model that rivals the likes of OpenAI’s GPT-4 and Claude 3.5 Sonnet in math, coding, and reasoning tasks.

The best part? You can run it directly on your machine (check pre-requisites), with full privacy and at absolutely no cost!

What is deepseek-r1?

DeepSeek’s first-generation of reasoning models with comparable performance to OpenAI-o1, including six dense models distilled from DeepSeek-R1 based on Llama and Qwen.

On January 20, 2025, the DeepSeek-R1 and DeepSeek-R1-Zero were released. They were based on V3-Base. Like V3, each is a mixture of experts with 671B total parameters and 37B activated parameters. They also released some “DeepSeek-R1-Distill” models, which are not based on R1. Instead, they are similar to other open-weight models like LLaMA and Qwen, fine-tuned on synthetic data generated by R1. The model I have installed and tested is DeepSeek R1 Distill Qwen 7Billion parameters.

Prerequisites

I’ll walk through the process of setting up a local environment on a MacBook Pro M3 (18GB) for testing the DeepSeek model using Ollama, n8n, and Docker via OrbStack. If you’re looking to get hands-on with an LLM like DeepSeek, follow these steps carefully to get your system set up. This setup is suitable ONLY for performing PoCs and development environment.

Before we begin, make sure you have the following:

MacBook Pro M3 with 18GB RAM
Docker installed (via OrbStack - https://orbstack.dev/download)
Ollama installed (https://ollama.com)
n8n installed (https://docs.n8n.io/hosting — for automating workflows, we’ll use this to test DeepSeek)
Terminal Access (iTerm2 — https://iterm2.com — for installing deepseek LLM via ollama)

Let’s dive into the steps!

Step 1: Install n8n Using Docker Compose on OrbStack
We’ll use Docker Compose to spin up n8n on OrbStack.

Create a folder for the n8n setup:

mkdir ~/n8n-docker && cd ~/n8n-docker

2. Create a simple docker-compose.yml file for n8n:

version: '3.9'

services:
  n8n:
    image: n8nio/n8n:latest
    container_name: n8n
    ports:
      - "5678:5678"
    volumes:
      - ./n8n_data:/home/node/.n8n # Persistent storage for workflows and data
    restart: unless-stopped

3. Start the n8n service:

docker-compose up -d

Check if n8n is running via OrbStack

4. Open n8n in your browser: http://localhost:5678. Setup an owner account and Log in using the credentials.

You can request free n8n license key (emailed to you) to unlock selected paid features on your community edition of n8n. You can enter and activate your key as shown below.

Step 2: Install Ollama

 ~/Doc/AI-Projects  brew install ollama                     
Warning: ollama 0.5.7 is already installed and up-to-date.
To reinstall 0.5.7, run:
  brew reinstall ollama

Step 3: Download the DeepSeek 7B model using Ollama:

~/Doc/AI-Projects  ollama run deepseek-r1:7b                                    
pulling manifest
pulling 96c415656d37... 100% ▕████████████████▏ 4.7 GB
pulling 369ca498f347... 100% ▕████████████████▏  387 B
pulling 6e4c38e1172f... 100% ▕████████████████▏ 1.1 KB
pulling f4d24e9138dd... 100% ▕████████████████▏  148 B
pulling 40fb844194b2... 100% ▕████████████████▏  487 B
verifying sha256 digest
writing manifest
success
>>> /bye

 ~/Doc/AI-Projects  ollama list                                  
NAME              ID              SIZE      MODIFIED
deepseek-r1:7b    0a8c26691023    4.7 GB    26 hours ago

Step 4: Integrate DeepSeek with n8n

Let’s set up a workflow in n8n to interact with the DeepSeek model.

4.1: Create Chat Trigger, Basic LLM Chain and Ollama Chat Model nodes

4.2: Configure Ollama Chat Model and test the connectivity

Double-click on the Ollama Chat Model node and configure the Ollama Base URL.

Once the connection is tested successfully, select the Deepseek model we have downloaded deepseek-r1:7b under parameters.

Step 5: Test DeepSeek 7B Model

Now that everything is set up:

Test more complex queries using the DeepSeek 7B model.
Create workflows in n8n to automate LLM-based tasks, such as summarisation, Q&A, or sentiment analysis.

Simple test:

Madhu: who are you

<think>

</think>

Greetings! I'm DeepSeek-R1, an artificial intelligence assistant created by DeepSeek. I'm at your service and would be delighted to assist you with any inquiries or tasks you may have.



Madhu: create terraform code to deploy eks cluster in aws


<think> Okay, I need to create a Terraform code to deploy an EKS cluster on AWS. Let me think about how to approach this.

First, I should outline the main components needed for deploying EKS using AWS. The key parts are the master node and worker nodes. So, I'll probably use Terraform modules like ec2 for general EC2 setup, ebs for adding storage, rds for the database, elb for the load balancer, and autoscaling groups to manage scaling.

I remember that EKS requires a cluster name which should be unique, so using a random string would make sense. I'll include a list of required modules at the top of my file to ensure they're loaded first.

Next, I need to define resources for each node type. The master will have an instance type like t2.micro, and workers can use r5.micro with a higher vpc_id for better performance since workers are in the same subnet as the master.

For storage, using ProvisionedS3Bucket makes sense because it's easy to manage and provides persistent storage. I'll set up both a default bucket and maybe an object store for EKS secrets or logs.

The database should be RDS, so I'll configure a MySQL or PostgreSQL instance in the same subnet as the master for consistency.

The load balancer is crucial for traffic distribution. I'll create an ELB that directs traffic to the EKS cluster nodes. The LB needs to be in the same VPC and Security Group as the master to ensure all nodes are reachable.

Autoscaling groups will help manage scaling based on load and temperature. I'll set up two groups, one for scaling out and another for scaling back, with appropriate policies so they don't interfere with each other.

I should also include environment variables in the Infrastructure Block for easy deployment from different environments like dev, staging, or prod.

It's important to note that EKS requires specific IAM roles for each resource. I might need to create these roles in a separate Terraform file or handle them within this code using assume_iam_role statements.

Wait, does the worker node need its own storage? Maybe using an S3 bucket per node isn't efficient, so perhaps using a shared storage solution like EFS or a persistent volume would be better. Or maybe I can use the same storage as the master for simplicity since they're in the same subnet.

I'm also thinking about security groups. They need to allow SSH access and connect all nodes (including ELB) to each other. So, I'll define a security group that includes both nodes and the ELB.

Another consideration is network interfaces. Each node's VPC ID should match so they're in the same subnet for communication.

I should make sure all necessary modules are imported at the top of the file, like module 'ec2', 'ebs', etc., to avoid any undefined variable errors.

Also, I need to define a list of parameter values that can be overridden or changed between environments. This way, each deployment environment can have its own configuration without rebuilding the entire code.

Putting it all together, I'll structure the code with modules at the top, then define variables and resources in order. Each node type (master and worker) will be defined using their respective modules. The EKS cluster will include all these components plus the autoscaling groups for scaling management.

I should also ensure that the output includes all necessary information like cluster name, master IP, etc., so users can easily deploy without manual input.

Finally, I'll include a note about how to apply the changes and test the deployment, as well as mentioning the IAM roles required. This will help the user understand what steps to take next after running the Terraform code. </think>

To deploy an EKS cluster using Terraform on AWS, you can follow these steps with the provided code:

Define Required Modules: Ensure all necessary modules are imported first.

Set Up Variables: Create a variable list for deployment configuration.

Define Resources:

Master Node
Worker Nodes
Storage Solutions (S3, RDS)
Load Balancer
Autoscaling Groups
Create Infrastructure Block: Manage environment-specific configurations.

Define Tags and Output: Include useful metadata for deployment.

Write Terraform Code:

# Top of the file with required modules
module "ec2"
  define "parameters" = [
    "region",
    "cluster_name",
    "vpc_id",
    "security_group",
    "KeyName", 
    "efs_size",
    "s3_bucket_name",
    "rds_db_name",
    "master BootTime",
    "worker BootTime"
  ]

# Infrastructure configuration

module = "ec2"

var Parameters = parameters()

# Define CloudFormation stack variables
var Region = Parameters.region
var ClusterName = Parameters.cluster_name
var VpcId = Parameters.vpc_id
var SecurityGroup = Parameters.security_group
var KeyName = Parameters.KeyName
var EfSSize = Parameters.efs_size
var S3BucketName = Parameters.s3_bucket_name
var RdsDbName = Parameters.rds_db_name

var Master = "t2.micro"
var Worker = "r5.micro"

# Define storage solutions
var StorageSolution = {
  type: "provisioned_s3_bucket",
  bucket_name: S3BucketName,
  region: Region
}

var EksClusterStorage = {
  type: "efs",
  root_size_in_gigabytes: EfSSize,
  region: Region
}

# Define database solution
var Rds = {
  type: "rds",
  engine: "mysql",
  name: RdsDbName,
  region: Region,
  key_name: KeyName,
  storage_type: "persistent",
  availability_zone: VpcId[0].Availability_Zone
}

# Define load balancer configuration
var LoadBalancer = {
  type: "elastic_load_balancer",
  name: ClusterName LoadBalancer,
  region: Region,
  load_balancer subnet_id: VpcId[0].Subnet_id,
  security_groups: [SecurityGroup],
  inboundrules: [{
    destination_port: 80,
    protocol: "TCP"
  }]
}

# Define autoscaling groups
var AutoscalingOut = {
  type: "autoscaling",
  scaling_out enabled: true,
  min_count: 2,
  max_count: 6,
  policy: { target_arn: "arn:aws:elasticloadbalancing:Region::app:elb/LoadBalancer/Status" }
}

var AutoscalingIn = {
  type: "autoscaling",
  scaling_in enabled: true,
  min_count: 2,
  max_count: 6,
  policy: { target_arn: "arn:aws:elasticloadbalancing:Region::app:elb/LoadBalancer/Status" }
}

# Apply changes
apply {
  # Define the master node
  ec2.master(InstanceType = Master, KeyName = KeyName, AvailabilityZone = VpcId[0].Availability_Zone,
    SecurityGroupIds = [SecurityGroup], SubnetId = VpcId[0].Subnet_id, 
    Storage = StorageSolution, EnableNetworking: true)

# Define the worker nodes
  map "workers" {
    Worker,
    KeyName = KeyName,
    AvailabilityZone = VpcId[0].Availability_Zone,
    SecurityGroupIds = [SecurityGroup],
    SubnetId = VpcId[0].Subnet_id,
    Storage = StorageSolution,
    EnableNetworking: true
  }

# Define the EKS cluster with master and worker nodes
  eks(Storage = EksClusterStorage, LoadBalancer = LoadBalancer, AutoscalingGroups = [AutoscalingOut, AutoscalingIn])

# Infrastructure blocks
  infrastructureBlock "parameters" {
    parameters
  }

  infrastructureBlock "environment" {
    environment = Parameters.environment
  }
}

# Output information for deployment confirmation
output "cluster_name" = ClusterName
output "master_ip" = ec2.master.ip_address
output "workers_count" = (number of workers)
This code provides a comprehensive configuration to deploy an EKS cluster using Terraform on AWS. It includes:

Master Node: Uses a T2.micro instance with RDS for storage and networking.
Worker Nodes: Utilizes R5.micro instances, providing better performance compared to master nodes.
Storage: Both S3 and EFS are configured to provide redundancy and in-cluster storage solutions.
Load Balancer: Ensures traffic is distributed efficiently among all cluster nodes.
Autoscaling Groups: Manages scaling based on load and temperature, with two groups for scaling out/in.
To use this code:

Ensure Terraform Installation: Confirm that Terraform is installed and configured correctly.
Define Parameters: Create a YAML configuration file for your specific environment (dev, staging, prod).
Apply Changes: Use terraform apply to deploy the EKS cluster based on your configurations.
Note: The code assumes you have IAM roles set up with appropriate permissions for EKS operations, including RDS, S3, and ELB access. Ensure these roles are available before running the deployment.

Conclusion

The DeepSeek R1 LLM stands out for its ability to run locally, offering a privacy-first, efficient, and cost-effective solution compared to other cloud-based LLMs. Unlike most models that require significant infrastructure or internet connectivity, DeepSeek — especially when paired with tools like n8n and Ollama — provides a streamlined workflow for testing locally.

What sets DeepSeek apart is its focus on lightweight deployment without compromising performance, making it an ideal choice for developers looking to test models locally or build workflows tailored to specific use cases. While other LLMs might offer higher-scale models or extensive APIs, they often come with added costs, latency, and reliance on external infrastructure. DeepSeek bridges this gap by delivering powerful local processing while maintaining flexibility and ease of integration.

Feel free to experiment with different workflows and use cases!

Learning continues.!

References

https://github.com/deepseek-ai/DeepSeek-R1
https://en.wikipedia.org/wiki/DeepSeek
https://www.deepseek.com

The Future of AI: Agent-Driven Paradigms and Transformations in Software Development

Madhu Kumar — Tue, 31 Dec 2024 11:45:15 +0000

🌟 As 2024 Comes to a Close: A Wake-Up Call for Developers 🌟

As we approach the close of 2024 and step into 2025, I want to caution developer communities about the profound transformation taking place in the software development landscape. The rise of agent-driven technologies and generative AI tools is accelerating automation at an unprecedented rate, redefining what it means to be a developer. While this brings opportunities for enhanced productivity, it also demands a shift in skillsets — moving away from routine coding tasks toward mastering AI collaboration, ethical AI governance, and high-level system design.

Developers who fail to adapt risk being left behind in a world where natural language interfaces, autonomous debugging, and self-healing systems are becoming the new norm. The era of creative, strategy-driven software engineering is upon us, and embracing these changes is no longer optional — it’s essential for staying relevant.

The rapid evolution of artificial intelligence (AI) has profoundly influenced countless industries, with software development being one of the most dynamic arenas of change. As we move toward an AI-driven future, intelligent agents — autonomous systems that perceive, reason, and act — are emerging as game-changers in software design, development, and deployment.

I want to briefly discuss the rise of AI agents, their potential to reshape the development process, and how this paradigm shift will influence the future of software engineering.

What Are AI Agents?
AI agents are programs that autonomously perform tasks by leveraging capabilities such as:

Perception: Interpreting data from the environment (e.g., sensor inputs, user commands).
Reasoning: Making decisions based on goals, constraints, and contexts.
Acting: Executing tasks with minimal or no human intervention.
Learning: Continuously improving performance by analyzing past outcomes.

Agents as Co-Developers
The most notable evolution of agents in software development is their role as co-developers or even autonomous developers. AI tools such as GitHub Copilot, ChatGPT, etc already demonstrate this concept, but future agents are expected to take it further by:

Designing architectures.
Debugging complex systems autonomously.
Refactoring legacy code without human input.
Collaborating with teams as virtual peers, capable of participating in standups and sprint planning.

Agent-Driven Software Development Paradigms

1. The Rise of Agent-Orchestrated Pipelines
In modern DevOps, automation is key. AI agents will further streamline Continuous Integration/Continuous Deployment (CI/CD) pipelines by:

Dynamically adapting configurations for optimal performance.
Automating rollbacks and recovery with predictive analysis.
Orchestrating microservices in real-time to adapt to changing workloads.
This will reduce the reliance on manual monitoring and intervention, empowering developers to focus on innovation.

2. Natural Language-Centric Development
The future of coding may no longer require extensive syntax knowledge. With natural language interfaces, developers will communicate with agents to:

Generate entire applications from high-level descriptions.
Add features by specifying functionality in plain language.
Perform advanced queries like “Optimise my database schema for this traffic pattern.”

3. Code-Generation Agents
Generative AI has already shown its potential in creating boilerplate code. The next leap is enabling agents to write domain-specific applications tailored to specific business requirements, even in industries with stringent compliance standards like finance, healthcare, or aviation.

4. Self-Healing Systems
AI agents will monitor systems in production, identifying issues, generating patches, and deploying fixes autonomously. This approach significantly minimises downtime and enhances reliability, reducing operational costs.

5. Democratisation of Development
Agent-driven paradigms will enable non-developers to build applications, lowering the barrier to entry. No-code/low-code platforms will evolve into agent-powered environments, where users can define complex workflows or applications without ever writing a line of code.

Impact on the Role of Software Developers

While AI agents will take over repetitive and resource-intensive tasks, developers will transition into roles that emphasise creativity, strategy, and oversight. Here’s how the role will shift:

1. Focus on High-Level Design
Developers will become system architects, focusing on designing modular and scalable solutions while agents handle implementation details.

2. Emphasis on Ethics and Governance
With AI taking centre stage, developers must ensure that agents adhere to ethical guidelines, fairness, and security standards.

3. Collaboration with AI Agents
Rather than replacing developers, agents will work alongside them. The ability to effectively manage and communicate with agents will become a critical skill.

4. Enhanced Productivity
By automating mundane tasks, agents will free developers to focus on creative problem-solving and long-term innovation.

Challenges and Risks

While the potential benefits of agent-driven development are immense, there are significant challenges to consider:

1. Trust and Transparency
How do we ensure that AI agents make ethical and reliable decisions? This includes understanding how they generate code or refactor systems.

2. Skills Gap
Developers will need new skill sets to work effectively with AI agents, such as prompt engineering, machine learning fundamentals, and human-AI collaboration techniques.

3. Security Vulnerabilities
Agents, if not properly managed, could introduce vulnerabilities into systems. Rigorous validation and monitoring processes will be essential.

4. Job Displacement
The democratisation of software development could displace some traditional roles. However, it will also create new opportunities in AI engineering, governance, and management.

Future Trends in AI and Software Development

Looking ahead, I anticipate several transformative trends:

1. Autonomous DevOps
AI agents will completely manage infrastructure provisioning, scaling, and monitoring, paving the way for self-operating clouds.

2. Hyper-Personalisation
Agents will enable developers to create ultra-customised software tailored to individual user needs.

3. AI-First Architectures
Applications will be designed with agents as primary actors, orchestrating workflows, interactions, and decisions.

4. Real-Time Collaboration Across Geographies
Agent-driven development will facilitate real-time collaboration, allowing globally distributed teams to work seamlessly across time zones and languages.

Conclusion

The future of software development is undeniably agent-driven. While challenges exist, the opportunities to enhance productivity, democratise innovation, and create intelligent systems are unparalleled. Developers must embrace this shift by upskilling, collaborating with agents, and focusing on creativity and ethical oversight.

As AI agents become more sophisticated, the way we think about building software will fundamentally change — shifting from writing code to defining goals, from debugging to designing, and from deployment to seamless orchestration.

The dawn of agent-driven development is here, and it’s poised to reshape the software landscape in profound and exciting ways.

Exploring AWS EKS Auto Mode: A Simplified Kubernetes Experience

Madhu Kumar — Sat, 21 Dec 2024 15:52:28 +0000

EKS Auto Mode extends AWS management of Kubernetes clusters beyond the cluster itself, to allow AWS to also set up and manage the infrastructure that enables the smooth operation of your workloads. You can delegate key infrastructure decisions and leverage the expertise of AWS for day-to-day operations. Cluster infrastructure managed by AWS includes many Kubernetes capabilities as core components, as opposed to add-ons, such as compute autoscaling, pod and service networking, application load balancing, cluster DNS, block storage, and GPU support.

Features

EKS Auto Mode provides the following high-level features:

Streamline Kubernetes Cluster Management: EKS Auto Mode streamlines EKS management by providing production-ready clusters with minimal operational overhead. With EKS Auto Mode, you can run demanding, dynamic workloads confidently, without requiring deep EKS expertise.

Application Availability: EKS Auto Mode dynamically adds or removes nodes in your EKS cluster based on the demands of your Kubernetes applications. This minimizes the need for manual capacity planning and ensures application availability.

Efficiency: EKS Auto Mode is designed to compute costs while adhering to the flexibility defined by your NodePool and workload requirements. It also terminates unused instances and consolidates workloads onto other nodes to improve cost efficiency.

Security: EKS Auto Mode uses AMIs that are treated as immutable for your nodes. These AMIs enforce locked-down software, enable SELinux mandatory access controls, and provide read-only root file systems. Additionally, nodes launched by EKS Auto Mode have a maximum lifetime of 21 days (which you can reduce), after which they are automatically replaced with new nodes. This approach enhances your security posture by regularly cycling nodes, aligning with best practices already adopted by many customers.

Automated Upgrades: EKS Auto Mode keeps your Kubernetes cluster, nodes, and related components up to date with the latest patches, while respecting your configured Pod Disruption Budgets (PDBs) and NodePool Disruption Budgets (NDBs). Up to the 21-day maximum lifetime, intervention might be required if blocking PDBs or other configurations prevent updates.

Managed Components: EKS Auto Mode includes Kubernetes and AWS cloud features as core components that would otherwise have to be managed as add-ons. This includes built-in support for Pod IP address assignments, Pod network policies, local DNS services, GPU plug-ins, health checkers, and EBS CSI storage.

Customisable NodePools and NodeClasses: If your workload requires changes to storage, compute, or networking configurations, you can create custom NodePools and NodeClasses using EKS Auto Mode. While default NodePools and NodeClasses can’t be edited, you can add new custom NodePools or NodeClasses alongside the default configurations to meet your specific requirements.

Before Auto Mode

After Auto Mode

Amazon EKS Auto Mode managed instances

Amazon EKS Auto Mode automates routine tasks for creating new EC2 Instances, and attaches them as nodes to your EKS cluster. EKS Auto Mode detects when a workload can’t fit onto existing nodes, and creates a new EC2 Instance.

Amazon EKS Auto Mode is responsible for creating, deleting, and patching EC2 Instances. You are responsible for the containers and pods deployed on the instance.

EC2 Instances created by EKS Auto Mode are different from other EC2 Instances, they are managed instances. These managed instances are owned by EKS and are more restricted. You can’t directly access or install software on instances managed by EKS Auto Mode.

AWS suggests running either EKS Auto Mode or self-managed Karpenter. You can install both during a migration or in an advanced configuration. If you have both installed, configure your node pools so that workloads are associated with either Karpenter or EKS Auto Mode.

Standard EC2 Instance

You are responsible for patching and updating the instance.
EKS is not responsible for the software on the instance.
You can delete the EC2 Instance using the EC2 API.
You can use SSH to access the EC2 Instance.
You determine the operating system and image (AMI).
You can deploy workloads that rely on Windows or Ubuntu functionality.
You determine what instance type and family to launch.

EKS Auto Mode managed instance

AWS automatically patches and updates the instance.
EKS is responsible for certain software on the instance, such as kubelet, the container runtime, and the operating system.
EKS determines the number of instances deployed in your account. If you delete a workload, EKS will reduce the number of instances in your account.
You can deploy pods and containers to the managed instance.
AWS determines the operating system and image.
You can deploy containers based on Linux, but without specific OS dependencies.
AWS determines what instance type and family to launch. You can use a Node Pool to limit the instance types EKS Auto Mode selects from.

Identity and access in EKS Auto Mode

In EKS Auto Mode, AWS IAM roles are automatically mapped to Kubernetes permissions through EKS access entries, removing the need for manual configuration of aws-auth ConfigMaps or custom bindings. When you create a new auto mode cluster, EKS automatically creates the corresponding Kubernetes permissions using Access entries, ensuring that AWS services and cluster components have the appropriate access levels within both the AWS and Kubernetes authorization systems. This automated integration reduces configuration complexity and helps prevent permission-related issues that commonly occur when managing EKS clusters.

Cluster IAM role
The Cluster IAM role is an AWS Identity and Access Management (IAM) role used by Amazon EKS to manage permissions for Kubernetes clusters. This role grants Amazon EKS the necessary permissions to interact with other AWS services on behalf of your cluster, and is automatically configured with Kubernetes permissions using EKS access entries.

Node IAM role
The Node IAM role is an AWS Identity and Access Management (IAM) role used by Amazon EKS to manage permissions for worker nodes in Kubernetes clusters. This role grants EC2 instances running as Kubernetes nodes the necessary permissions to interact with AWS services and resources, and is automatically configured with Kubernetes RBAC permissions using EKS access entries.

VPC networking and load balancing in EKS Auto Mode

When you use EKS Auto Mode, AWS manages the VPC Container Network Interface (CNI) configuration and load balancer provisioning for your cluster. You can influence networking behaviors by defining NodeClass objects and applying specific annotations to your Service and Ingress resources, while maintaining the automated operational model that EKS Auto Mode provides.

VPC CNI networking
With EKS Auto Mode, you do not directly configure the AWS VPC CNI. AWS manages node and pod networking. Instead, you create a NodeClass Kubernetes object.

Configure VPC CNI with NodeClass
The NodeClass resource in EKS Auto Mode allows you to customize certain aspects of the VPC Container Network Interface (CNI) configuration without directly managing the CNI plugin. Through NodeClass, you can specify security group selections, control node placement across VPC subnets, set SNAT policies, configure network policies, and enable network event logging. This approach maintains the automated operational model of EKS Auto Mode while providing flexibility for network customization.

You can use a NodeClass to:

elect a Security Group for Nodes
Control how nodes are placed on VPC Subnets
Set the Node SNAT Policy to random or disabled
Set the Network Policy to Default Deny or Default Allow
Enable Network Event Logging to a file.

Considerations

EKS Auto Mode automatically formats and configures NVMe local storage on supported instance types. For nodes with multiple NVMe drives, EKS sets up a RAID 0 array. This automation eliminates the need for manual formatting and RAID configuration of local NVMe storage in EKS clusters.
Amazon EKS Auto Mode does not support AWS Fault Injection Service. For more information, see Managing Fault Injection Service experiments in the AWS Resilience Hub User Guide.
You do not need to install the Neuron Device Plugin on EKS Auto Mode nodes.
If you have other types of nodes in your cluster, you need to configure the Neuron Device plugin to not run on auto mode nodes. For more information, see Control if a workload is deployed on EKS Auto Mode nodes.

EKS Auto Mode supports:

EKS Network Policies.
The HostPort and HostNetwork options for Kubernetes Pods.
Pods in public or private subnets.

EKS Auto Mode does not support:

Security Groups per Pod (SGPP).
Custom Networking. The IP Addresses of Pods and Nodes must be from the same CIDR Block.
Warm IP, warm prefix, and warm ENI configurations.
Minimum IP targets configuration.
Enabling or disabling prefix delegation.
Other configurations supported by the open-source AWS CNI.
Network Policy configurations such as conntrack timer customization (default is 300s).
Exporting network event logs to CloudWatch.

Sources

https://aws.amazon.com/blogs/containers/getting-started-with-amazon-eks-auto-mode

https://docs.aws.amazon.com/eks/latest/userguide/automode.html

Debunking the Misconception: Gaming as a Beneficial Pursuit

Madhu Kumar — Thu, 31 Aug 2023 18:25:19 +0000

I was thrilled to have been in the sunny City of Angels (Los Angeles, CA) for last weekend's (August 25–26, 2023) Amazon Web Services (AWS) VALORANT Champions VIP Hospitality experience. I was involved in some Tech Talks and had the privilege to watch the Riot Games—VALORANT Champions final.

Unlike my other tech blogs, this one is different, and I will talk about gaming.

We had a very interesting discussion on the concept of the Valorant game with Alex “Goldenboy” Mendez, who is an esports host and commentator with roots as a competitive Call of Duty player. Followed by a roundtable speaking engagement with key technical leaders from AWS and Riot Games.

AWS x Riot partnership — https://aws.amazon.com/sports/riot

AWS and Riot Games have teamed up to transform how Riot’s Esports content is created and distributed in the cloud and reimagine how fans can experience League of Legends, VALORANT, and League of Legends: Wild Rift Esports events through AWS’ first-ever data analytics integration for esports broadcasts.

In July 2022, Riot Games announced they were going all-in on AWS, focused on powering Riot’s infrastructure, including their new global content factories that publish Riot’s esports, music production, analytics, statistics, and animation. Other possible workloads include leveraging AWS instances to create a future slate of cloud-based on-demand and live content, and using AWS to power the build-out of Riot’s cloud-first production facilities based in Dublin, APAC, and Seattle.

How Riot has advanced in broadcast and gaming experience

Riot already uses AWS’ services across its games to focus on how it designs and deploys content to help provide the best possible game experience, using edge computing like AWS Outposts and AWS Local Zones. Riot aims for latency under 80 milliseconds for League of Legends, and under 35 milliseconds for Valorant. Now Riot is going to use AWS to enhance its esports broadcasts throughout each competitive season for LoL Esports, the Valorant Champions Tour, and Wild Rift Esports.

As part of the collaboration, Riot is selecting AWS as its official cloud artificial intelligence, cloud machine learning, cloud deep learning, and cloud services provider. It’s impressive that a game company like Riot has to use a lot of those technologies to get its games out these days.

Now let us talk about Valorant game and general misconception about gaming.

What is Valorant?
Valorant is a team-based first-person tactical hero shooter set in the near future. Players play as one of a set of Agents, characters based on several countries and cultures around the world. In the main game mode, players are assigned to either the attacking or defending team, with each team having five players on it.

Objective of the game
The aim is to become the first team to win 13 rounds. To accomplish this, players must either eliminate the members of the opposing team or finish the objective assigned to them. For Attackers, this involves planting a spike (or the game’s equivalent of a bomb). Another unique feature of Valorant is its use of character abilities. Each character has a set of abilities that can be used to gain an advantage in combat.

Game results: https://valorantesports.com/news/valorant-champions-2023-recap-evil-geniuses-end-their-roller-coaster-year-in-glory/en-gb

The Misconception:

For years, gaming has been associated with negative connotations. Concerns about addiction, violence, social isolation, and negative impacts on physical and mental health have fueled the belief that gaming is a bad habit. However, it’s important to remember that, like any form of entertainment, moderation is key. Just as binge-watching television shows or spending excessive time on social media can have negative effects, so can overindulging in gaming.

The Reality: The Advantages of Gaming

Cognitive Benefits: Contrary to popular belief, gaming can have a positive impact on cognitive abilities. Many video games like Valorant require strategic thinking, problem-solving, and quick decision-making. Games like puzzle-solving adventures, strategy simulations, and even some action games enhance players’ analytical and critical thinking skills.
Coordination and Reflexes: Action-oriented games like Valorant demand high levels of hand-eye coordination and fast reflexes. Gamers often develop better motor skills and reaction times, which can extend to improved performance in daily activities.
Teamwork and Collaboration: Multiplayer games like Valorant, whether played online or in person, encourage players to collaborate, communicate, and work as a team to achieve goals. This can translate into real-world scenarios where teamwork is essential.
Creativity and Imagination: Many games immerse players in expansive worlds and narratives, fostering creativity and imagination. Games like Minecraft have even been used as tools for education, allowing players to construct and explore their own imaginative creations.
Stress Relief: Gaming can provide an effective escape from the stresses of everyday life. Engaging in a virtual world can be a healthy way to unwind and relax, much like reading a book or watching a movie.
Learning Opportunities: Simulation games, historical strategy games, and educational games offer players a chance to learn about various subjects in an interactive manner. Players can gain insights into history, science, economics, and more, often without even realising it.
Persistence and Resilience: Many games present challenges and obstacles that require repeated attempts to overcome. This cultivates persistence, resilience, and the understanding that success often comes after multiple failures.
Social Interaction: Contrary to the notion that gaming promotes social isolation, online multiplayer games facilitate social interaction among players from around the world. These interactions can lead to friendships, teamwork, and even a sense of belonging within gaming communities.

Moderation is Key
It’s essential to acknowledge that while gaming offers numerous advantages, excessive or irresponsible gaming can indeed lead to negative consequences. Balance is crucial. Just as one wouldn’t spend every waking moment watching television, individuals should manage their gaming time wisely.

Final Thoughts
Gaming is a multifaceted hobby that extends far beyond mere entertainment. It’s a realm where creativity, critical thinking, teamwork, and stress relief coalesce. By dispelling the misconception that gaming is inherently a bad habit, we can better appreciate its potential to enhance cognitive abilities, improve social skills, and provide a healthy outlet for relaxation.

So, let’s shift our perspective and recognise that the world of gaming is rich with opportunities for growth and enrichment. I personally look at it as a professional sport. As with any activity, the key lies in approaching it mindfully and striking a balance that aligns with a fulfilling and well-rounded life.

From Imagination to Reality: Exploring the Path of Generative AI

Madhu Kumar — Tue, 18 Jul 2023 05:10:55 +0000

Generative AI isn’t just a technology or a business case — it is a key part of a society in which people and machines work together.

What is generative AI?

Generative AI can learn from existing artifacts to generate new, realistic artifacts (at scale) that reflect the characteristics of the training data but don’t repeat it. It can produce a variety of novel content, such as images, video, music, speech, text, software code and product designs.

Generative AI uses a number of techniques that continue to evolve. Foremost are AI foundation models, which are trained on a broad set of unlabeled data that can be used for different tasks, with additional fine-tuning. Complex math and enormous computing power are required to create these trained models, but they are, in essence, prediction algorithms.

Today, generative AI most commonly creates content in response to natural language requests — it doesn’t require knowledge of or entering code.

What are the benefits and applications of generative AI?

Foundation models, including generative pretrained transformers (which drive ChatGPT), are among the AI architecture innovations that can be used to automate, augment humans or machines, and autonomously execute business and IT processes.

The benefits of generative AI include faster product development, enhanced customer experience, and improved employee productivity, but the specifics depend on the use case. End users should be realistic about the value they are looking to achieve, especially when using a service as is, which has major limitations. Generative AI creates artifacts that can be inaccurate or biased, making human validation essential and potentially limiting the time it saves workers. Gartner recommends connecting use cases to KPIs to ensure that any project either improves operational efficiency, creates net new revenue, or creates better experiences.

In a recent Gartner webinar poll of more than 2,500 executives, 38% indicated that customer experience and retention are the primary purposes of their generative AI investments. This was followed by revenue growth (26%), cost optimisation (17%), and business continuity (7%).

What are the risks of generative AI?

The risks associated with generative AI are significant and rapidly evolving. A wide array of threat actors have already used the technology to create “deep fakes” or copies of products, and generate artifacts to support increasingly complex scams.

ChatGPT and other tools like it are trained on large amounts of publicly available data. They are not designed to be compliant with General Data Protection Regulation (GDPR) and other copyright laws, so it’s imperative to pay close attention to your enterprises’ uses of the platforms.

Oversight risks to monitor include:

Lack of transparency. Generative AI and ChatGPT models are unpredictable, and not even the companies behind them always understand everything about how they work.
Accuracy. Generative AI systems sometimes produce inaccurate and fabricated answers. Assess all outputs for accuracy, appropriateness and actual usefulness before relying on or publicly distributing information.
Bias. You need policies or controls in place to detect biased outputs and deal with them in a manner consistent with company policy and any relevant legal requirements.
Intellectual property (IP) and copyright. There are currently no verifiable data governance and protection assurances regarding confidential enterprise information. Users should assume that any data or queries they enter into the ChatGPT and its competitors will become public information, and we advise enterprises to put in place controls to avoid inadvertently exposing IP.
Cybersecurity and fraud. Enterprises must prepare for malicious actors’ use of generative AI systems for cyber and fraud attacks, such as those that use deep fakes for social engineering of personnel, and ensure mitigating controls are put in place. Confer with your cyber-insurance provider to verify the degree to which your existing policy covers AI-related breaches.
Sustainability. Generative AI uses significant amounts of electricity. Choose vendors that reduce power consumption and leverage high-quality renewable energy to mitigate the impact on your sustainability goals.

What are some practical uses of generative AI today?

The field of generative AI will progress rapidly in both scientific discovery and technology commercialisation, but use cases are emerging quickly in creative content, content improvement, synthetic data, generative engineering, and generative design.

In-use, high-level practical applications today include the following.

Written content augmentation and creation: Producing a “draft” output of text in a desired style and length
Question answering and discovery: Enabling users to locate answers to input, based on data and prompt information
Tone: Text manipulation, to soften language or professionalize text
Summarisation: Offering shortened versions of conversations, articles, emails and webpages
Simplification: Breaking down titles, creating outlines and extracting key content
Classification of content for specific use cases: Sorting by sentiment, topic, etc.
Chatbot performance improvement: Bettering “sentity” extraction, whole-conversation sentiment classification and generation of journey flows from general descriptions
Software coding: Code generation, translation, explanation and verification

Emerging use cases with long-term impacts include:

Creating medical images that show the future development of a disease
Synthetic data helping augment scarce data, mitigate bias, preserve data privacy and simulate future scenarios
Applications proactively suggesting additional actions to users and providing them with information
Legacy code modernisation

Should I craft a usage policy for generative AI?

Your workforce is likely already using generative AI, either on an experimental basis or to support their job-related tasks. To avoid “shadow” usage and a false sense of compliance, Gartner recommends crafting a usage policy rather than enacting an outright ban.

Keep the policy simple — it can be as streamlined as three don’ts and two do’s if using ChatGPT or other off-the-shelf model:

Don’t input any personally identifiable information.
Don’t input any sensitive information.
Don’t input any company IP.
Do turn off history if using external tools (like ChatGPT) that enable that choice.
Do closely monitor outputs, which are subject to sometimes subtle but meaningful hallucinations, factual errors, and biased or inappropriate statements.

If the company is using its own instance of a large language model, the privacy concerns that inform limiting inputs go away. However, the need to keep a close eye on outputs remains.

Where should I start with generative AI?

Many enterprises have generative AI pilots for code generation, text generation, or visual design underway. To establish a pilot, you can take one of three routes:

Off-the-shelf. Use an existing foundational model directly by inputting prompts. You might, for example, ask the model to create a job description for a software engineer or suggest alternative subject lines for marketing emails.
Prompt engineering. Program and connect software to a foundational model and leverage it. This technique, which is the most common of the three, allows you to use public services while protecting IP and leveraging private data to create more precise, specific, and useful responses. Building an HR benefits chatbot that answers employee questions about company-specific policies is an example of prompt engineering.
Custom. Building a new foundational model goes beyond the reach of most companies, but it’s possible to tune a model. This involves adding a layer or proprietary data in a way that significantly alters the way the foundational model behaves. While costly, customising a model offers the highest level of flexibility.

Who are the major tech providers in the generative AI market?

The Generative AI marketplace is on fire. Beyond the big platform players, there are hundreds of specialty providers funded by ample venture capital and a wave of new open-source models and capabilities. Enterprise application providers, such as Salesforce and SAP, are building LLM capabilities into their platforms. Organisations like Microsoft, Google, Amazon Web Services (AWS), and IBM have invested hundreds of millions of dollars and massive compute power to build the foundational models on which services like ChatGPT and others depend.

Gartner considers the current major players to be as follows:

Google has two large language models, Palm, a multimodal model, and Bard, a pure language model. They are embedding their generative AI technology into their suite of workplace applications, which will immediately get it in the hands of millions of people.
Microsoft and OpenAI are marching in lockstep. Like Google, Microsoft is embedding generative AI technology into its products, but it has the first-mover advantage and buzz of ChatGPT on its side.
Amazon has partnered with Hugging Face, which has a number of LLMs available on an open-source basis, to build solutions. Amazon also has Bedrock, which provides access to generative AI on the cloud via AWS, and has announced plans for Titan, a set of two AI models that create text and improve searches and personalisation.
IBM has multiple foundation models and a strong ability to fine-tune both its own and third-party models by injecting data and retraining and employing the model.

This blog is an extract from the Gartner site; comments and credits should go to the original authors from Gartner.

Reference: https://www.gartner.com/en/insights/generative-ai-for-business

Building and Launching a Serverless GraphQL React Application with AWS Amplify: A Step-by-Step Guide

Madhu Kumar — Sun, 23 Apr 2023 05:01:27 +0000

Introduction

Serverless computing has been gaining popularity in recent years due to its numerous benefits, such as scalability, cost-effectiveness, and flexibility. AWS Amplify is a development platform that allows developers to build and deploy serverless applications quickly and easily. In this blog post, I will guide you through the process of building and launching a serverless GraphQL React application with AWS Amplify.

Prerequisites

Before getting started, you will need the following:

An AWS account.
Node.js installed on your machine.
Basic knowledge of React and GraphQL.

Step-1: Create a new React app

To get started, let’s create a new React application. Open up your terminal and run the following command:

npx create-react-app my-app

~/Documents/amplify-hackathon  npx create-react-app my-app                                                                                                                                  ✔  10:27:05

Creating a new React app in /Users/macpro/Documents/amplify-hackathon/my-app.

Installing packages. This might take a couple of minutes.
Installing react, react-dom, and react-scripts with cra-template...


added 1423 packages in 43s

235 packages are looking for funding
  run `npm fund` for details

Initialized a git repository.

Installing template dependencies using npm...

added 62 packages, and changed 1 package in 8s

235 packages are looking for funding
  run `npm fund` for details
Removing template package using npm...


removed 1 package, and audited 1485 packages in 3s

235 packages are looking for funding
  run `npm fund` for details

6 high severity vulnerabilities

To address all issues (including breaking changes), run:
  npm audit fix --force

Run `npm audit` for details.

Created git commit.

Success! Created my-app at /Users/macpro/Documents/amplify-hackathon/my-app
Inside that directory, you can run several commands:

  npm start
    Starts the development server.

  npm run build
    Bundles the app into static files for production.

  npm test
    Starts the test runner.

  npm run eject
    Removes this tool and copies build dependencies, configuration files
    and scripts into the app directory. If you do this, you can’t go back!

We suggest that you begin by typing:

  cd my-app
  npm start

Happy hacking!

This will create a new React app in a directory called my-app.

~/Documents/amplify-hackathon/my-app  main !4 ?5  ll                                                                                ✔  11:00:37
total 5136
-rw-r--r--     1 macpro  staff   3.3K 23 Apr 10:27 README.md
drwxr-xr-x     9 macpro  staff   288B 23 Apr 10:35 amplify
drwxr-xr-x  1053 macpro  staff    33K 23 Apr 10:52 node_modules
-rw-r--r--     1 macpro  staff   1.6M 23 Apr 10:53 package-lock.json
-rw-r--r--     1 macpro  staff   867B 23 Apr 10:53 package.json
drwxr-xr-x     8 macpro  staff   256B 23 Apr 10:27 public
drwxr-xr-x    14 macpro  staff   448B 23 Apr 11:00 src

To start our React app we can run from the my-app directory “npm start”.

~/Documents/amplify-hackathon/my-app  main  npm start                                                                                                                   ✔  07:42:12

> my-app@0.1.0 start
> react-scripts start

(node:29873) [DEP_WEBPACK_DEV_SERVER_ON_AFTER_SETUP_MIDDLEWARE] DeprecationWarning: 'onAfterSetupMiddleware' option is deprecated. Please use the 'setupMiddlewares' option.
(Use `node --trace-deprecation ...` to show where the warning was created)
(node:29873) [DEP_WEBPACK_DEV_SERVER_ON_BEFORE_SETUP_MIDDLEWARE] DeprecationWarning: 'onBeforeSetupMiddleware' option is deprecated. Please use the 'setupMiddlewares' option.
Starting the development server...
Compiled successfully!

You can now view my-app in the browser.

  Local:            http://localhost:3000
  On Your Network:  http://192.168.0.87:3000

Note that the development build is not optimized.
To create a production build, use npm run build.

webpack compiled successfully

This will start the development server at http://localhost:3000. Press ctrl+c to stop the server.

Step-2: Install AWS Amplify CLI

Next, we need to install the AWS Amplify CLI. Open up your terminal and run the following command:

npm install -g @aws-amplify/cli

~/Documents/amplify-hackathon/my-app  main !5 ?3  npm install -g @aws-amplify/cli           1 ✘  4s  22:11:35

changed 26 packages in 25s

7 packages are looking for funding
  run `npm fund` for details
npm notice
npm notice New minor version of npm available! 9.4.0 -> 9.6.5
npm notice Changelog: https://github.com/npm/cli/releases/tag/v9.6.5
npm notice Run npm install -g npm@9.6.5 to update!
npm notice

This will install the Amplify CLI globally on your machine or upgrade the old version.

Step 3: Configure Amplify

Now that we have installed the Amplify CLI, let’s configure it. Run the following command in your terminal:

~/Documents/amplify-hackathon/my-app  main  amplify configure            ✔  07:48:51
Follow these steps to set up access to your AWS account:

Sign in to your AWS administrator account:
https://console.aws.amazon.com/
Press Enter to continue

Specify the AWS Region
? region:  us-east-1
Follow the instructions at
https://docs.amplify.aws/cli/start/install/#configure-the-amplify-cli

to complete the user creation in the AWS console
https://console.aws.amazon.com/iamv2/home#/users/create
Press Enter to continue

Enter the access key of the newly created user:
? accessKeyId:  # YOUR_ACCESS_KEY_ID
? secretAccessKey:  # YOUR_SECRET_ACCESS_KEY
This would update/create the AWS Profile in your local machine
? Profile Name:  # (default)

Successfully set up the new user.

This will prompt you to enter your AWS credentials. Follow the prompts to enter your Access Key ID and Secret Access Key.

Step 4: Initialise Amplify

Now that Amplify is configured, let’s initialise it in our React app. Run the following command in your terminal:

amplify init

~/Documents/amplify-hackathon/my-app  main  amplify init                                                                                                                                    ✔  10:28:31

Note: It is recommended to run this command from the root of your app directory
? Enter a name for the project myapp
The following configuration will be applied:

Project information
| Name: myapp
| Environment: dev
| Default editor: Visual Studio Code
| App type: javascript
| Javascript framework: react
| Source Directory Path: src
| Distribution Directory Path: build
| Build Command: npm run-script build
| Start Command: npm run-script start

? Initialize the project with the above configuration? Yes
Using default provider  awscloudformation
? Select the authentication method you want to use: AWS profile

For more information on AWS Profiles, see:
https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html

? Please choose the profile you want to use default
Adding backend environment dev to AWS Amplify app: d2fcsc4w0p2um2

# This "input" configures a global authorization rule to enable public access to
Deployment completed.
Deployed root stack myapp [ ======================================== ] 4/4
 amplify-myapp-dev-103057       AWS::CloudFormation::Stack     CREATE_COMPLETE                Sun Apr 23 2023 10:31:34…
 DeploymentBucket               AWS::S3::Bucket                CREATE_COMPLETE                Sun Apr 23 2023 10:31:25…
 AuthRole                       AWS::IAM::Role                 CREATE_COMPLETE                Sun Apr 23 2023 10:31:18…
 UnauthRole                     AWS::IAM::Role                 CREATE_COMPLETE                Sun Apr 23 2023 10:31:19…

✔ Help improve Amplify CLI by sharing non sensitive configurations on failures (y/N) · yes
Deployment state saved successfully.
✔ Initialized provider successfully.
✅ Initialized your environment successfully.

Your project has been successfully initialized and connected to the cloud!

Some next steps:
"amplify status" will show you what you've added already and if it's locally configured or deployed
"amplify add <category>" will allow you to add features like user login or a backend API
"amplify push" will build all your local backend resources and provision it in the cloud
"amplify console" to open the Amplify Console and view your project status
"amplify publish" will build all your local backend and frontend resources (if you have hosting category added) and provision it in the cloud

Pro tip:
Try "amplify add api" to create a backend API and then "amplify push" to deploy everything

This will initialise Amplify in your React app. Follow the prompts to configure Amplify.

Step 5: Add a GraphQL API

With Amplify initialised, we can now add a GraphQL API. Run the following command in your terminal:

amplify add api

~/Documents/amplify-hackathon/my-app  main !1 ?1  amplify add api                                                                                                                    ✔  3m 2s  10:32:13

? Select from one of the below mentioned services: GraphQL
? Here is the GraphQL API that we will create. Select a setting to edit or continue Continue
? Choose a schema template: Single object with fields (e.g., “Todo” with ID, name, description)

⚠️  WARNING: your GraphQL API currently allows public create, read, update, and delete access to all models via an API Key. To configure PRODUCTION-READY authorization rules, review: https://docs.amplify.aws/cli/graphql/authorization-rules

✅ GraphQL schema compiled successfully.

Edit your schema at ~/Documents/amplify-hackathon/my-app/amplify/backend/api/myapp/schema.graphql or place .graphql files in a directory at ~/Documents/amplify-hackathon/my-app/amplify/backend/api/myapp/schema
✔ Do you want to edit the schema now? (Y/n) · no
✅ Successfully added resource myapp locally

✅ Some next steps:
"amplify push" will build all your local backend resources and provision it in the cloud
"amplify publish" will build all your local backend and frontend resources (if you have hosting category added) and provision it in the cloud

This will prompt you to choose a type of API. Select “GraphQL” and follow the prompts to configure your API.

Step 6: Define your GraphQL schema

Now that we have added a GraphQL API to our Amplify project, we need to define the schema. The schema defines the types and operations that can be performed on our API. Open up the amplify/backend/api/myapp/schema.graphql file in your code editor and replace the contents with the following code:

type Todo @model {
  id: ID!
  name: String!
  description: String
  done: Boolean
}

This code defines a new Todo type with fields for id, name, description, and done. The @model directive tells Amplify to create a DynamoDB table and all the required CRUD operations for this type.

Step 7: Deploy your GraphQL API

Now that we have defined our schema, we can deploy our GraphQL API. Enter the following command in your terminal:

amplify push

 ~/Documents/amplify-hackathon/my-app  main !1 ?1  amplify push                                                                                                                         ✔  34s  10:34:53
⠏ Fetching updates to backend environment: dev from the cloud.
⚠️  WARNING: Some types do not have authorization rules configured. That means all create, read, update, and delete operations are denied on these types:
  - Todo
Learn more about "@auth" authorization rules here: https://docs.amplify.aws/cli/graphql/authorization-rules
✅ GraphQL schema compiled successfully.

Edit your schema at /Users/macpro/Documents/amplify-hackathon/my-app/amplify/backend/api/myapp/schema.graphql or place .graphql files in a directory at /Users/macpro/Documents/amplify-hackathon/my-app/amplify/backend/api/myapp/schema
✔ Successfully pulled backend environment dev from the cloud.
⠴ Building resource api/myapp
⚠️  WARNING: Some types do not have authorization rules configured. That means all create, read, update, and delete operations are denied on these types:
  - Todo
Learn more about "@auth" authorization rules here: https://docs.amplify.aws/cli/graphql/authorization-rules
✅ GraphQL schema compiled successfully.

Edit your schema at /Users/macpro/Documents/amplify-hackathon/my-app/amplify/backend/api/myapp/schema.graphql or place .graphql files in a directory at /Users/macpro/Documents/amplify-hackathon/my-app/amplify/backend/api/myapp/schema

    Current Environment: dev

┌──────────┬───────────────┬───────────┬───────────────────┐
│ Category │ Resource name │ Operation │ Provider plugin   │
├──────────┼───────────────┼───────────┼───────────────────┤
│ Api      │ myapp         │ Create    │ awscloudformation │
└──────────┴───────────────┴───────────┴───────────────────┘
✔ Are you sure you want to continue? (Y/n) · yes

⚠️  WARNING: Some types do not have authorization rules configured. That means all create, read, update, and delete operations are denied on these types:
  - Todo
Learn more about "@auth" authorization rules here: https://docs.amplify.aws/cli/graphql/authorization-rules
✅ GraphQL schema compiled successfully.

Edit your schema at /Users/macpro/Documents/amplify-hackathon/my-app/amplify/backend/api/myapp/schema.graphql or place .graphql files in a directory at /Users/macpro/Documents/amplify-hackathon/my-app/amplify/backend/api/myapp/schema
⠴ Building resource api/myapp
⚠️  WARNING: Some types do not have authorization rules configured. That means all create, read, update, and delete operations are denied on these types:
  - Todo
Learn more about "@auth" authorization rules here: https://docs.amplify.aws/cli/graphql/authorization-rules
✅ GraphQL schema compiled successfully.

Edit your schema at /Users/macpro/Documents/amplify-hackathon/my-app/amplify/backend/api/myapp/schema.graphql or place .graphql files in a directory at /Users/macpro/Documents/amplify-hackathon/my-app/amplify/backend/api/myapp/schema
? Do you want to generate code for your newly created GraphQL API Yes
? Choose the code generation language target javascript
? Enter the file name pattern of graphql queries, mutations and subscriptions src/graphql/**/*.js
? Do you want to generate/update all possible GraphQL operations - queries, mutations and subscriptions Yes
? Enter maximum statement depth [increase from default if your schema is deeply nested] 2

Deployment completed.
Deploying root stack myapp [ ---------------------------------------- ] 0/2
 amplify-myapp-dev-103057       AWS::CloudFormation::Stack     UPDATE_IN_PROGRESS             Sun Apr 23 2023 10:36:28…
 apimyapp                       AWS::CloudFormation::Stack     CREATE_IN_PROGRESS             Sun Apr 23 2023 10:36:32…
Deployed api myapp [ ======================================== ] 6/6
import React, { useEffect, useState } from 'react';
 GraphQLAPI                     AWS::AppSync::GraphQLApi       CREATE_COMPLETE                Sun Apr 23 2023 10:36:40…
 GraphQLAPIDefaultApiKey215A6D… AWS::AppSync::ApiKey           CREATE_COMPLETE                Sun Apr 23 2023 10:36:44…
import logo from './logo.svg';
import './App.css';

function App() {
  return (
    <div className="App">
      <header className="App-header">
        <img src={logo} className="App-logo" alt="logo" />
        <p>
          Edit <code>src/App.js</code> and save to reload.
        </p>
        <a
          className="App-link"
          href="https://reactjs.org"
          target="_blank"
          rel="noopener noreferrer"
        >
          Learn React
        </a>
      </header>
    </div>
  );
}

 GraphQLAPINONEDS95A13CF0       AWS::AppSync::DataSource       CREATE_COMPLETE                Sun Apr 23 2023 10:36:44…
 GraphQLAPITransformerSchema3C… AWS::AppSync::GraphQLSchema    CREATE_COMPLETE                Sun Apr 23 2023 10:37:45…
 Todo                           AWS::CloudFormation::Stack     CREATE_COMPLETE                Sun Apr 23 2023 10:38:35…
 CustomResourcesjson            AWS::CloudFormation::Stack     CREATE_COMPLETE                Sun Apr 23 2023 10:38:49…
import React from 'react';

✔ Generated GraphQL operations successfully and saved at src/graphql
Deployment state saved successfully.

GraphQL endpoint: https://lsa4eg44ufffhg3zwrottvemfq.appsync-api.us-east-1.amazonaws.com/graphql
GraphQL API KEY: da2-anzozaxgsrhl7jr3yxam4k3oee

GraphQL transformer version: 2

Follow the prompts to deploy your API. Amplify will create a new DynamoDB table and all the required CRUD operations for our Todo type.

Step 8: Add the AWS AppSync SDK to your app

To interact with our GraphQL API, we need to add the AWS AppSync SDK to our app. Enter the following command in your terminal:

npm install aws-appsync

~/Documents/amplify-hackathon/my-app  main !1 ?3  npm install aws-appsync                                                                                                           ✔  4m 37s  10:39:44

npm WARN deprecated querystring@0.2.0: The querystring API is considered Legacy. new code should use the URLSearchParams API instead.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.

added 205 packages, and audited 1690 packages in 35s

238 packages are looking for funding
  run `npm fund` for details

6 high severity vulnerabilities

To address all issues (including breaking changes), run:
  npm audit fix --force

Run `npm audit` for details.

Step 9: Configure the AWS AppSync SDK

Now that we have added the AWS AppSync SDK to our app, we need to configure it to work with our API. Create a new file called aws-exports.js in the src folder and add the following code:

const awsmobile = {
  "aws_project_region": "<your-project-region>",
  "aws_appsync_graphqlEndpoint": "<your-api-endpoint>",
  "aws_appsync_region": "<your-api-region>",
  "aws_appsync_authenticationType": "

Now, replace the placeholders (, , and ) with the appropriate values from your Amplify project. You can find these values in the aws-exports.js file in the root of your project directory.

Step 10: Create a component to display a list of todos

Now that we have configured the AWS AppSync SDK, we can create a component to display a list of todos. Create a new file called TodoList.js in the src folder and add the following code:

import React, { useEffect, useState } from 'react';
import { API, graphqlOperation } from 'aws-amplify';

import { listTodos } from './graphql/queries';

function TodoList() {
  const [todos, setTodos] = useState([]);

  useEffect(() => {
    async function fetchTodos() {
      try {
        const todoData = await API.graphql(graphqlOperation(listTodos));
        const todos = todoData.data.listTodos.items;
        setTodos(todos);
      } catch (err) {
        console.log('error fetching todos: ', err);
      }
    }

    fetchTodos();
  }, []);

  return (
    <div>
      <h2>Todos</h2>
      <ul>
        {todos.map(todo => (
          <li key={todo.id}>
            <strong>{todo.name}</strong>: {todo.description}
          </li>
        ))}
      </ul>
    </div>
  );
}

export default TodoList;

This code defines a new component called TodoList that fetches a list of todos from our GraphQL API and displays them in an unordered list.

Step 11: Add the TodoList component to your app

Now that we have created the TodoList component, we can add it to our app. Open up the App.js file in your code editor and replace the contents with the following code:

import React from 'react';
import './App.css';

import TodoList from './TodoList';

function App() {
  return (
    <div className="App">
      <header className="App-header">
        <h1>My Todo App</h1>
      </header>
      <main>
        <TodoList />
      </main>
    </div>
  );
}

export default App;

_This code imports the TodoList component and adds it to our app.-

Step 12: Launch your app

Now that we have added the TodoList component to our app, we can launch it. Enter the following command in your terminal:

npm start

~/Documents/amplify-hackathon/my-app/src  main !4 ?6  npm start                                                                                                                        ✔  11s  10:53:26

> my-app@0.1.0 start
> react-scripts start

(node:45156) [DEP_WEBPACK_DEV_SERVER_ON_AFTER_SETUP_MIDDLEWARE] DeprecationWarning: 'onAfterSetupMiddleware' option is deprecated. Please use the 'setupMiddlewares' option.
(Use `node --trace-deprecation ...` to show where the warning was created)
(node:45156) [DEP_WEBPACK_DEV_SERVER_ON_BEFORE_SETUP_MIDDLEWARE] DeprecationWarning: 'onBeforeSetupMiddleware' option is deprecated. Please use the 'setupMiddlewares' option.
Starting the development server...
Compiled successfully!

You can now view my-app in the browser.

  Local:            http://localhost:3000
  On Your Network:  http://192.168.0.87:3000

Note that the development build is not optimized.
To create a production build, use npm run build.

webpack compiled successfullyThis will start the development server and open your app in your default browser. You should see a list of todos displayed on the screen.

With this app as a starting point with no functionality, you can add new features and functionality to create a powerful and scalable application.

ERROR:

If you face the error below Module not found: Error: Can’t resolve ‘aws-amplify’, install this module.

 ~/Documents/amplify-hackathon/my-app  main !4 ?5  npm start                                                                                                                             ✔  4s  10:45:33

> my-app@0.1.0 start
> react-scripts start

(node:44800) [DEP_WEBPACK_DEV_SERVER_ON_AFTER_SETUP_MIDDLEWARE] DeprecationWarning: 'onAfterSetupMiddleware' option is deprecated. Please use the 'setupMiddlewares' option.
(Use `node --trace-deprecation ...` to show where the warning was created)
(node:44800) [DEP_WEBPACK_DEV_SERVER_ON_BEFORE_SETUP_MIDDLEWARE] DeprecationWarning: 'onBeforeSetupMiddleware' option is deprecated. Please use the 'setupMiddlewares' option.
Starting the development server...
import React, { useEffect, useState } from 'react';
Failed to compile.

Module not found: Error: Can't resolve 'aws-amplify' in '/Users/macpro/Documents/amplify-hackathon/my-app/src'
ERROR in ./src/TodoList.js 6:0-52
Module not found: Error: Can't resolve 'aws-amplify' in '/Users/macpro/Documents/amplify-hackathon/my-app/src'

webpack compiled with 1 error

To fix the above error, we need to install aws-amplify module by running this command “npm install aws-amplify”

~/Documents/amplify-hackathon/my-app/src  main !4 ?6  npm install aws-amplify                                                                                                               ✔  10:51:00

npm WARN deprecated source-map-url@0.4.1: See https://github.com/lydell/source-map-url#deprecated
npm WARN deprecated urix@0.1.0: Please see https://github.com/lydell/urix#deprecated
npm WARN deprecated resolve-url@0.2.1: https://github.com/lydell/resolve-url#deprecated
npm WARN deprecated source-map-resolve@0.5.3: See https://github.com/lydell/source-map-resolve#deprecated
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
import React, { useEffect, useState } from 'react';
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
npm WARN deprecated uglify-es@3.3.9: support for ECMAScript is superseded by `uglify-js` as of v3.13.0

added 1871 packages, and audited 3561 packages in 1m

251 packages are looking for funding
  run `npm fund` for details

6 high severity vulnerabilities

To address all issues (including breaking changes), run:
  npm audit fix --force

Run `npm audit` for details.

Step 13: Clean-up

Within the project directory that you want to delete, run the following amplify delete command:

For locally accessible projects
Within the project directory that you want to delete, run the following amplify delete command:

amplify delete

For cloud-based projects

Pull the backend environment associated with your application to your local environment by running the following amplify pull command:

amplify pull

Within the project directory that you want to delete, run the following amplify delete command:

amplify delete

Output:

~/Documents/amplify-hackathon/my-app  main !5 ?5  amplify delete                                                                                                                  ✔  5s  11:55:13
✔ Are you sure you want to continue? This CANNOT be undone. (This will delete all the environments of the project from the cloud and wipe out all the local files created by Amplify CLI) (y/N) · yes
⠋ Deleting resources from the cloud. This will take a few minutes.
Deleting env: dev.
✔ Project deleted in the cloud.
✅ Project deleted locally.

Conclusion

Through this tutorial, I have demonstrated how easy it can be to build a serverless application using AWS Amplify, which is very basic and has no functionality. I encourage you to continue exploring the many features and capabilities of Amplify and to use it to build your own amazing serverless applications.

If you want to build real-time multi-user experiences using GraphQL on AWS Amplify - https://aws.amazon.com/blogs/mobile/build-real-time-multi-user-experiences-using-graphql-on-aws-amplify

If you want to build AWS AppSync GraphQL Photo Sample application - https://github.com/aws-samples/aws-amplify-graphql

Legends of Linux Trivia — Red Hat Free Badges

Madhu Kumar — Sun, 26 Mar 2023 13:05:27 +0000

How well do you know Linux?

Red Hat, a leading provider of open source software solutions, is now offering a fantastic opportunity for Linux enthusiasts and collectors to earn badges that showcase their expertise in Linux. All you need to do is successfully complete a Red Hat quiz and score 100% to earn one of the three badges on offer. You can choose to earn one, two or all three badges, depending on how much of a Linux expert you are.

It’s a great way to demonstrate your proficiency in Linux and add some impressive credentials to your resume. So why wait? Take the quiz and show the world how well you know Linux!

Red Hat Enterprise Linux Trivia — Red Hat Titan

Linux Command-Line Trivia — Command-Line Captain

Linux Open Source Trivia — Open Sourcer-er

AWS Hero: A Distinction Worth Earning

Madhu Kumar — Sat, 11 Feb 2023 07:36:35 +0000

Becoming an AWS Hero is a recognition awarded by Amazon Web Services (AWS) to individuals who have demonstrated a deep understanding of the AWS platform and have made significant contributions to the AWS community.

The AWS Heroes program recognises a vibrant, worldwide group of AWS experts whose enthusiasm for knowledge-sharing has a real impact within the community. Heroes go above and beyond to share knowledge in a variety of ways including online via social media, blog posts, open source projects, videos, and forums; or in person at conferences, workshops, and user group events.

I'm always active in dev communities, but, I began my journey a few years ago by actively participating in the AWS community, sharing my knowledge with others and learning from them (for example, through technical blogs, as a speaker, and organising AWS immersion days and game days, to name a few). When I heard about the AWS Community Builders program, I applied and got selected, and I haven't looked back since then. The support I received from AWS (community managers and members) is phenomenal, and that helped me come out of my shell, recognise and invest in my own development, bring more visibility to what I do, share my knowledge with the wider AWS community, and achieve my goal. Today, I'm proud to say that I'm an AWS Hero.

What is the AWS Heroes Program?

AWS is comprised of users whose enthusiasm has created a vibrant worldwide community of experts who go above and beyond to share their extensive AWS knowledge in many ways, including through social media, blogs, events, user groups, and workshops.

The purpose of the AWS Heroes program is to recognise and honour the most engaged and influential developers who have a significant impact within the community. It also provides Heroes a place to tell their story and connect with like-minded developers. If you are looking to learn from and connect with experienced members of the AWS community, check out their bios and connect online.

Discovering the hero within is a journey that cannot be accomplished through a one-size-fits-all approach. However, I’ve got some valuable tips that I personally used to unleash my inner hero. Keep reading to learn more and embark on your own hero’s journey!

Develop your AWS expertise: Gain a deep understanding of the AWS services and technologies through hands-on experience, attending AWS events and webinars, and reading AWS documentation and best practices. (https://aws.amazon.com/products)
Engage with the AWS community: Participate in AWS user groups, forums, and social media, and help others with their AWS-related questions and challenges. (https://aws.amazon.com/developer/community)
Share your expertise: Write blog posts, present at AWS events and meetups, and create educational resources to share your AWS knowledge with others.
Get certified: Obtain one or more AWS certifications, such as the AWS Certified Solutions Architect, to demonstrate your technical expertise. (https://aws.amazon.com/certification)
Attend AWS events: Attend AWS re:Invent, AWS Summit, and other AWS events to network with other AWS experts and learn about the latest AWS developments. (https://aws.amazon.com/events)
Collaborate with others: Work with other AWS experts on projects and initiatives to build your network and showcase your expertise.
Seek recognition: Apply for the AWS Community Builder program to receive recognition for your contributions to the AWS community.

You can learn more about AWS Community Builder Program: https://aws.amazon.com/developer/community/community-builders

Focus on a specific area of AWS: While it's important to have a broad understanding of AWS, focusing on a specific area can help you become an expert in that area and make a bigger impact in the community.
Engage with the AWS open-source community: Participate in AWS open-source projects, contribute code, and share your contributions on your personal blog or social media. (https://aws.amazon.com/opensource)
Stay up-to-date: Stay informed of the latest AWS news and developments by following the AWS blog, attending webinars, and reading industry publications. (https://aws.amazon.com/blogs/aws)
Participate in online forums: Engage with other AWS users and experts by answering questions, providing solutions, and sharing your expertise in online forums such as the AWS Developer Forums or the AWS Community Heroes program. (https://repost.aws)
Collaborate with AWS partners: Partner with AWS partners, such as AWS solution providers, to learn more about AWS solutions and help others. (https://partners.amazonaws.com)
Teach others: Organise and lead AWS training sessions, workshops, and meetups to share your knowledge with others and help them grow their AWS expertise. (https://www.aws.training)
Seek feedback: Ask for feedback from others in the AWS community to learn what you can do better and to get suggestions on areas where you can improve.

In conclusion, becoming an AWS Hero requires a combination of technical expertise, community engagement, and sharing your knowledge with others. By following these suggestions, you can create value for yourself, demonstrate your expertise in AWS and make valuable contributions to the AWS community.

"Good luck on your journey to becoming an AWS Hero!"

Disclaimer: This blog is meant only for guidance and my own opinions based on my experience, not as a definitive path to becoming an AWS Hero. I believe that every individual has unique talent and has their own ways to work on their self-development skills.

For more information on AWS Hero programme: https://aws.amazon.com/developer/community/heroes

Follow me: https://www.linkedin.com/in/cloudgeek7