DEV Community: Ricards Taujenis

Why I'm Heading to Warsaw for NBX 2026

Ricards Taujenis — Thu, 19 Mar 2026 11:56:47 +0000

There's no shortage of Web3 conferences these days.

But every now and then, an event stands out - not because of the hype, but because of the people and opportunities it brings together.

That's why I'm excited to share that I'll be joining Next Block Expo 2026 as an Official Ambassador.

Warsaw Is Becoming a Web3 Hotspot

On March 24–25, Warsaw will turn into one of the most important meeting points for the European Web3 ecosystem.

We're talking about:

2,000+ attendees
140+ speakers
Builders, investors, founders - all in one place

But scale isn't what makes an event valuable.

What really matters is what happens between people.

The Underrated Advantage: Smart Networking

One thing that really stood out to me this year is the networking experience.

As part of the event, attendees get access to a dedicated app designed to:

Schedule 1:1 meetings
Discover relevant people
Navigate the event efficiently

Because the difference between a "good" conference and a truly valuable one usually comes down to one thing:

Who you meet - and how intentionally you meet them.

Why I Decided to Get Involved

Joining as an ambassador wasn't just about attending.

It's about being part of something that:

Connects the right people
Supports early-stage builders
Pushes the ecosystem forward

Web3 is at a stage where signal matters more than noise.

And events like this help surface that signal.

See You There?

If you're planning to attend Next Block Expo 2026, I'd love to connect.

🎟️ You can register here: https://lnkd.in/d4m4Y4pV
Use promo code: Mozes721
If not this time - hopefully we'll cross paths at a future edition.

OpenClaw AI Agent on Raspberry Pi

Ricards Taujenis — Tue, 24 Feb 2026 11:47:23 +0000

OpenClaw is an open-source personal AI assistant that runs locally on hardware like a Raspberry Pi, keeping your data private and under your control. If you enjoy self-hosting and experimenting with AI agents, this setup is surprisingly straightforward.

Raspberry Pi Prep

SSH into your Pi and update the system for stability:

sudo apt update && sudo apt upgrade -y

Install Node.js 22+ if missing (required for OpenClaw), plus Python for potential dependencies:

sudo apt install nodejs npm python3 python3-pip -y

Run the one-liner installer, which handles Node detection and onboarding:

curl -fsSL https://openclaw.ai/install.sh | bash

Post-install, check setup:

openclaw doctor
openclaw status
openclaw dashboard

OpenClaw Overview

In a nutshell it acts as a 24/7 AI agent with persistent memory.

It integrated with apps like Telegram, WhatsApp, Discord etc. You can choose from multiple LLM providers depending on your needs and setup.

Onboarding process

After installation, launch the guided wizard:

openclaw onboard

Process Breakdown

Step 1: LLM Selection-- Prompts for model (e.g., Gemini), then API key entry.
Step 2: Channel Setup-- Picks interface like Telegram; inputs bot token from @botfather.
Step 3: Provider Link-- Links accounts (Google for Gemini, GitHub, etc.) for skills/tools.

Telegram Setup

Message @botfather on Telegram.
Send /newbot.
Name your bot (e.g., MyOpenClawBot).
Copy the API token provided by BotFather.

Approve pairing

In Telegram, search for your new bot.
Send /start (or any message) to generate a pairing code.
On your Pi, run:

openclaw pairing approve telegram [pairing-code]

You can now test by messaging the bot - responses should sync via your selected LLM across both the dashboard and Telegram.

Final Thoughts

OpenClaw is still very new and evolving quickly. Some users are already running it on devices like the Mac mini. I'll continue testing it on my Mac and plan to link Google Calendar, Mail, and Drive to explore its full potential.

Kickstart OpenCode with OpenRouter

Ricards Taujenis — Sun, 11 Jan 2026 16:32:16 +0000

AI coding tools evolve fast, and OpenCode stands out as an open-source agent rivaling Cursor or Claude Code CLI - fully terminal-native with LSP support, multi-session handling, and 75+ LLM providers via Models.dev.

Compared to locked-in alternatives that are subscription base you can pick models pay-as-you-go prioritizing privacy and flexibility.
Check my 5-minute setup video for a quick demo.

https://youtu.be/VSN3fCJcoIc

Installation

Start with the one-liner curl install - no Docker or complex deps needed:

curl -fsSL https://opencode.ai/install | bash .

This adds the opencode CLI globally. Verify with opencode --version, then launch via opencode. For VS Code integration, it pairs seamlessly as an LSP client. Full docs: opencode.ai/docs.

OpenRouter Setup

OpenRouter powers model access via its OpenAI-compatible API - sign up at openrouter.ai, grab a key, and fund credits (pay-per-token, starting free tiers).
Export these env vars (add to ~/.zshrc for persistence):

export OPENAI_API_BASE=https://openrouter.ai/api/v1
export OPENAI_API_KEY=your-openrouter-api-key

Source your shell (source ~/.zshrc) and relaunch. Screenshot your API keys page for readers to match. This unlocks 300+ models without switching providers.
I added some credits to OpenRouter just for more advanced models for different projects.

Source your shell (source ~/.zshrc) and relaunch. Screenshot your API keys page for readers to match. This unlocks 300+ models without switching providers.

Basic Usage

Run opencode in a repo to init: It prompts project context, then use slash commands in the TUI.

/connect: Link OpenRouter (auto-detects env vars).
/models: List/select (e.g., Claude 3.5 Sonnet or GPT-4o-filter free ones).
/init: Scans repo, suggests plan (e.g., "Analyze main.rs and create layers").
Core flow: /plan for outline, /build to generate/run code, /improve for refinements.

Self-Hosting n8n in 5 Minutes: Local Docker or VPS Setup

Ricards Taujenis — Fri, 12 Dec 2025 12:57:10 +0000

As a powerful open-source workflow automation tool running locally or in own server free of charge brings huge value to build future projects!
For more info check the website https://docs.n8n.io/ otherwise lets get started! 🏁🏁🏁

Docker Setup

To run locally you just need a simple Docker command.

# Build image
docker build -t my-n8n .

# Run container
docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  n8nio/n8n

Here, --name sets the container name, -p maps the port, and -v ensures your workflows are saved persistently."

Then in some time(because the size is 1.3GB) it should run and in the localhost port will see above internal sign in.

And that's practically it and you can start building your workflows!

Just don't rebuild the image without saving the volumes as you may delete them as I have before!

Webhooks & ngrok

Locally if you want n8n to communicate with external applications Webhook needs to work, and for that ngrok is required.

ngrok exposes your local n8n instance to the internet, so external apps can reach your webhooks.

Once a domain has been created and API key shared the docker file would be better to be replaced with docker-compose.yml file.

version: '3.8'
services:
  n8n:
    image: n8nio/n8n:latest
    ports:
      - "5555:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=your-secure-password
      - N8N_HOST=0.0.0.0
      - N8N_PORT=5678
    volumes:
      - n8n_data:/home/node/.n8n

  ngrok:
    image: ngrok/ngrok:latest
    command: ["http", "n8n:5678"]
    environment:
      - NGROK_AUTHTOKEN=your-ngrok-authtoken
    ports:
      - "4040:4040"
    depends_on:
      - n8n

volumes:
  n8n_data:

Then ones this is done and rebuild you can use Webhooks. 💪

Server setup

On a VPS with a public IP or domain, you don't need ngrok. Just point your DNS to the server and configure n8n with your domain.

As well let's then use compose file docker-compose.server.yml (tweak N8N_HOST to your domain):

version: '3.8'
services:
  n8n:
    image: n8nio/n8n:latest
    ports:
      - "5555:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=your-secure-password
      - N8N_HOST=0.0.0.0
      - N8N_PORT=5678
    volumes:
      - n8n_data:/home/node/.n8n

  ngrok:
    image: ngrok/ngrok:latest
    command: ["http", "n8n:5678"]
    environment:
      - NGROK_AUTHTOKEN=your-ngrok-authtoken
    ports:
      - "4040:4040"
    depends_on:
      - n8n

volumes:
  n8n_data:

The restart: always ensures n8n restarts automatically if the server reboots.

And run docker compose -f docker-compose.server.yml up -d.

Whether you're experimenting locally or deploying on a VPS, n8n gives you full control over your workflows. With Docker Compose, you can scale easily, secure your instance, and connect to external apps. Start building your automations today - without subscription costs.

How AI slop impacted content creators

Ricards Taujenis — Mon, 06 Oct 2025 07:44:23 +0000

As a content creator across different media types(blogging, YT) I have been “gutted” of how much of an impact it has made personally both on view count and financial.

While AI does help tremendously it as well at the same time diminishes importance in most ‘white collar’ jobs.

📉 View Count & Revenue Decline

It is no shocker that AI-generated content flooded a lot of platforms, pushing authentic creators down in search and recommendation algorithms due to sheer
Lower visibility leads to reduced engagement, watch time, and ad revenue.

Thus, these platforms have also cut our earnings in half due to it as it’s tough to compete and less people go to platforms to gain insight on different topics.

😞 Emotional Toll on Creators

Creators feel demoralized, questioning value of their work. The joy of creating is replaced by frustration and disillusionment.
Any level of authenticity seems feels diminished even if AI can construct cases a lot better.

🧭 Why Creators Are Going Silent

Some creators step back due to the overwhelming noise and lack of reward.
Others pause to reassess their purpose and whether authenticity still has a place.

While I have kept YT to some decent level of consistency, with blogging I have not due to this ‘AI slop’ and cutting of any sorts of rewards in the platforms.

🧠 Oversaturation & Algorithmic Noise

Creators who invest time and emotion into their work get buried under generic output.
Platforms are overwhelmed with mass-produced, low-effort content.

Before AI there was already competition in the field and just raising in all “white collar” type of job, but now it really disrupts it all.

My drop in view count and earnings made me demotivated to post a article for around 3 months. Whether this is my final post or just a pause, one thing is clear — authenticity has to find new ways to shine in a noisy, AI-saturated world.

How to setup RAG with VectorDB

Ricards Taujenis — Sat, 21 Jun 2025 14:08:04 +0000

You may come across a term called RAG by now it's being rapidly adopted and introduced in 2020.

Mainly it's heavily in use for LLM-based apps, chatbots AI customer support, internal knowledge assistants etc.

📊 Brief overview

Let's create a ticker-specific RAG database table example using Pinecone. In my project I needed to map stock, crypto name: ticker symbols to extract just the ticker symbol. I have as well a Youtube video what you can check bellow. 👇️

https://youtu.be/QDe3Gi2tXR8

Database setup

As mentioned I used Pinecone but there are as well other options like using Reddis and even Postgres has some support.
So ones you have created an account create a new index(table)

There are many options and it depends of course on the LLM model you use. If you use GPT then by all means use one of the predefined GPT embeddings. There is as well Llama and Microsoft configuration, for my use case I made a "Manual configuration" due to embeddings based on all-MiniLM-L6-v2 model in HuggingFace.

https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2

NOTE: It's really important to setup configs correctly as otherwise embeddings won't work. My Metric: cosine, Dimensions: 384, Type: Dense your's however may differ.

Ones created and running extract your API key and add to your .env for further embeddings.

📊 Prepare Dataset

Bellow you can see fraction of my .csv just to get a glimpse what I am embedding

text,label
TSLA,Tesla
AAPL,Apple
MSFT,Microsoft
BABA,Alibaba Group Holding Limited
...

For LLM I recommend using Jupyter or Google Colab rather then a regular IDE.

import os
from dotenv import load_dotenv
from sentence_transformers import SentenceTransformer
from datasets import load_dataset
from pinecone import Pinecone

load_dotenv()
pc_api_key= os.getenv("PINECONE_API_KEY")

dataset = load_dataset("Mozes721/stock-crypto-weather-dataset", data_files="crypto_mapppings.csv")
df = dataset["train"].to_pandas()

In above code I just import required packages like pinecone, and sentence_transformers used for embeddings.

I stored my training data in https://huggingface.co/new-dataset due to the fact it's LLM related same as for fine tunning rather then locally, but that is individual choice.

Build Alias Map

# Step 2: Create alias map
alias_to_ticker = {}

for _, row in df.iterrows():
    ticker = row['text'].upper()
    name = row['label'].lower()
    alias_to_ticker[ticker] = ticker
    alias_to_ticker[name] = ticker
    # Optional: add lowercase ticker too
    alias_to_ticker[ticker.lower()] = ticker

# Step 3: Prepare for embedding
aliases = list(alias_to_ticker.keys())
tickers = [alias_to_ticker[a] for a in aliases]

# Embed
model = SentenceTransformer('all-MiniLM-L6-v2')
embeddings = model.encode(aliases, convert_to_numpy=True)

# Step 5: Load Pinecone table
pc = Pinecone(api_key=pc_api_key)
index = pc.Index("stock-index")

So alias map is created and in the for loop iterate over rows on text and label. Append to alias tuple both name and ticker( in my mappings it should work on both ends if AAPL given should return AAPL if Apple then AAPL).

Then we fetch the model we want to embed it to and encode by converting to numpy ad then for now just load the index table.

Embed & Store in Pinecone

# Prepare vectors in correct format
vectors = []
for i in range(len(aliases)):
    vectors.append({
        "id": f"stock_{i}",
        "values": embeddings[i].tolist(),
        "metadata": {"ticker": tickers[i], "alias": aliases[i]}
    })

# Batch upsert to avoid 2MB limit
batch_size = 50
total_batches = (len(vectors) + batch_size - 1) // batch_size

for i in range(0, len(vectors), batch_size):
    batch = vectors[i:i + batch_size]
    index.upsert(vectors=batch)
    batch_num = i // batch_size + 1
    print(f"Batch {batch_num}/{total_batches} has been embedded and uploaded ({len(batch)} vectors)")

print("All city batches completed!")

The vectors should be prepared in an array, we go through a for loop in aliases. Then append to vector and have id, values and metadata defined.

Uploading to Pinecone needs to be done in batches to avoid 2MB upsert limit. When its done with batch_size we can upsert to stock-index table.

🤖 Querying with RAG

The testing face should be quite simple as long as data has been embedded properly and same LLM model is used.]

import os
from dotenv import load_dotenv
from sentence_transformers import SentenceTransformer
from pinecone import (
    Pinecone
)

class EmbeddingStockMapper:
    def __init__(self, model_name: str, pinecone_api_key: str):
        # Initialize the embedding model
        self.model = SentenceTransformer(model_name)

        pc = Pinecone(api_key=pinecone_api_key)
        self.index = pc.Index("stock-index")

    def get_stock_ticker(self, query):
        # Get embedding for the query
        query_embedding = self.model.encode(query, convert_to_numpy=True)

        # Search in Pinecone
        results = self.index.query(
            vector=query_embedding.tolist(),
            top_k=1,
            include_metadata=True
        )

        if results.matches:
            return results.matches[0].metadata['ticker']
        return None

# Initialize the mapper
load_dotenv()
pc_api_key= os.getenv("PINECONE_API_KEY")
mapper = EmbeddingStockMapper(model_name="all-MiniLM-L6-v2", pinecone_api_key=pc_api_key)

So we initialize the model with all-MiniLM-L6-v2 same as used before in embedings. Then create a method get_stock_ticker that will encode the query passed to it. It will then return a result.matches[0].metadata['ticker'] as per own specification that most closely matches.

test_queries = ["AAPL", "Apple Inc.", "apple", "What is the current stock price of Tesla.", "Google", "google", "TSLA", "Tesla", "tesla", "Microsoft Corporation", "microsoft"]

for query in test_queries:
    ticker = mapper.get_stock_ticker(query)
    print(f"Query: {query} -> Ticker: {ticker}")

//Output
Query: AAPL -> Ticker: AAPL
Query: Apple Inc. -> Ticker: AAPL
Query: apple -> Ticker: AAPL
Query: What is the current stock price of Tesla. -> Ticker: TSLA
Query: Google -> Ticker: GOOGL
Query: google -> Ticker: GOOGL
Query: TSLA -> Ticker: TSLA
Query: Tesla -> Ticker: TSLA
Query: tesla -> Ticker: TSLA
Query: Microsoft Corporation -> Ticker: MSFT
Query: microsoft -> Ticker: MSFT

Above you can see how it gracefully returned ticker symbols as per my request!

In all honesty I was astonished by the results. RAG is slowly getting traction and I think a this is a lot better approach even if there is a learning curve compared to just using ChatGPT API calls. But most of us have simple need for AI implementation so using the whole AI model can be deemed as an "overkill".

My repo you can find here for any questions feel free to ask.

Vibe Coding: The Good and the Ugly

Ricards Taujenis — Thu, 08 May 2025 13:27:40 +0000

If you have been around the dev block recently, you most likely heard of this new trend "vibe coding" my friend roped me into trying it with Cursor, and let me just tell you I have mixed feelings about it. Here's why.

The Good

When it comes to building a new project it feels liberating to vibe yourself to success! Not the same with legacy code however but not impossible.

Real-time feedback and rapid iteration

Cursor(like WindSurf) updates on the fly, making it a lot more faster and you don't have to switch between writing and running as not only it updates scripts but it can as well create new ones!

As you can see from above screenshot for Cursor it at first asked for permission to mkdir and then automatically created schema.sql script.

Fresh start

Vibe coding on fresh project creates less baggage compared to legacy code. In addition it gives you sense of momentum, exploration and blazingly fast builds!
In addition it can do deploys to your Cloud provider if ssh keys are present and manage it in terminal(so not just code).

Great for ideation and brainstorming

Stuck on what tools to use? Postgres or Mongo? RabbitMQ? Kubernetes? Or what API system to use and even language Cursor and other AI IDEs can help with that by leveraging it's deep understanding of all the tools in the disposal.

Just have to be explicit and scaffold based on my goals, and then gives me full stack with languages, reasoning and tools.

I asked a question of what I am included to build and to follow up with README.md tech stack and architecture tree including language of choice and other tools that would be optimal. ☝️

The Ugly

Even though these AI IDEs have access to your whole repo, they can still duplicate logic and other issues mentioned bellow. Thus extensive monitoring and NOT commiting before checking is a must. 🕵🏻

Code duplication

While code assistant IDEs have access to whole repo, it still sometimes create same functions in different directories. Like I had with my Rust project bellow. 👇

If you pay attention you can see that verify_pin function was created in plugin, service and utils module lvl by Cursor, so when some code doesn't work it can often recreate similar logic elsewhere and forget that there is already something implemented.

Tooling mismatch

This hits hardest in JavaScript and Python. With massive ecosystems, AI assistants often install libraries that don't play well together - or that are outdated.

With React it can install certain dependencies like Supabase client and server side dependencies, same as with TS that are not compatible.

As we all know we can not always use the latest packages and documentation/methods are not available for some packages or are stale with AI not knowing it but just pasting.

Too fast, lack of reasoning

Sometimes it feels too easy to "vibe yourself to success", but often context of repo is misunderstood and explanation of WHY particular approach was taken falls short. Thus it's easy to fall into deep woods when you see 10 scripts generate and instead of reasoning and understand it you just close a blind eye and hope for AI Gods to fix possible issues.

To conclude I must say Cursor undeniably is a game-changer. But just because something becomes 3x easier doesn't mean it can not wrap up "technical debt" in the future, especially if your not fully familiar with the tech like me when it comes to Rust.

The $20/month price is a bit steep, especially when WindSurf offers a free tier and GitHub Copilot is cheaper. Still, for now, I'm sticking with Cursor.

That said, I'll be more cautious. Just because the assistant offers changes doesn't mean you should accept them blindly. Review them. Test them. Because duplicated functions, unnecessary utils, and mismatched packages can snowball fast.

Local Llama Setup: A Python Developer's Guide

Ricards Taujenis — Thu, 23 Jan 2025 00:42:53 +0000

As using chatGPTis API is becoming more and more expensive and number of tokens are limited there comes a point in your life that have to look for alternatives. Thats where Llama comes in!

Alternatively you can use smaller models (3B parameters instead of 7B)
Use bitsandbytes for 8-bit quantization, which reduces memory usage significantly.
If you don't have strong GPU can always outsource to cloud options that are out there like Google Colab, Hugging Face Inference API, RunPod

Accessing Llama Models

To start off Hugging Face is the primary platform used for accessing Llama models(e.g., meta-llama/Llama-2-7b-chat-hf).

https://huggingface.co

Create your account in Hugging Face👆 to start using LLM models provided by Llama.
If your ambitious can as well create own model if not there are a bunch of models to choose from. 🤖

Most people including me just need text-to-text model so typical choose would be meta-llama/Llama-2–7b-chat-hf.

Once the model has been selected be sure to request access to the model by adding credentials.

huggingface-cli login

Then you will have to login in terminal to use the models. In your huggingface profile go to Settings > Access Tokens, generate your access token that you will paste in.

Using the Model

In your python app we should use conda instead of regular venv be sure to install it activating it is similar as venv.

https://docs.anaconda.com/working-with-conda/environments/

//Required instalation for conda PyTorch
conda install pytorch torchvision torchaudio cpuonly -c pytorch
//Required python packages for huggingface etc
pip install transformers accelerate sentencepiece huggingface_hub
//To reduce memory usage you can as well install
pip install bitsandbytes
//Activate conda
conda activate myenv

For this demonstration will just make it a simple as possible in main.py the power lies when implementing RAG (Retrieval-Augmented Generation)) or fine tuning the model.

import transformers
import torch

def main():
    # Load Llama model using transformers pipeline
    pipeline = transformers.pipeline(
        "text-generation",
        model="meta-llama/Llama-2-7b-chat-hf",  # Replace with your model path if using a local model
        model_kwargs={"torch_dtype": torch.bfloat16},
        device_map="auto"
    )

    # Start the Llama pipeline
    while True:
        # Get user input
        query = input("\nYou: ")

        # Exit condition
        if query.lower() in ["exit", "quit"]:
            print("Goodbye!")
            break

        # Handle the query
        try:
            # Construct the prompt
            messages = [
                {"role": "user", "content": query},
            ]

            # Generate a response using the Llama model
            outputs = pipeline(
                messages,
                max_new_tokens=256,  # Adjust as needed
            )

            # Extract and print the response
            response = outputs[0]["generated_text"][-1]["content"]
            print(f"Bot: {response}")
        except Exception as e:
            print(f"Error handling query: {e}")

if __name__ == "__main__":
    main()

Note: The model i used computation heavy(CPU, GPU) and due to enormous parameters this particular 7 Billion parameters so if it doesn't break and hangs it may be due to weak PC.

Conclusion

As AI doesn't seem to fade and hype keeps on going good good to be more familiarized with it if not building own model might as well implement in own project with fine tuning or implementing it with RAG.
Of course IF your PC can handle it. 😉

Can Pinterest Help Build Your Personal Brand?

Ricards Taujenis — Tue, 10 Dec 2024 21:33:04 +0000

In todays age personal branding is more important then ever, while most of us focus on YouTube, blogging, personal website, GitHub(as a developer), Link bio(like linktree).

Pinterest works similarly to affiliate links, directing users to external content where the shared content actually resides.

While it's true that Pinterest is better suited for creative, visually-driven fields like art, tattoos, and fashion, it can also be a valuable tool for IT professionals. Although results may not be instantaneous, men and women alike can leverage Pinterest for personal branding.

Setting up Pinterest

Ones you login with email, google or facebook you can start by creating different boards based on content that you want to share.

Above you can see my different boards i have created over time(the last one i have been invited to).

Some social platforms like YouTube will automatically suggest option to create a Pin on Pinterest. If not I suggest create manually through Canva by selecting Pinterest pin 👇

https://www.canva.com/

Pinterest offers SEO benefits that can drive traffic to your website or content. Additionally, there are paid options for promoting pins, but I use the free version.

Statistics

Out of the many pins I've created, some have performed exceptionally well. For instance, my article 'How to Stop Vaping for Good' received 25 clicks, with 8 coming from Pinterest.

As you can see from above picture while most dont get any traction I made one article listed bellow.

https://richard-taujenis.medium.com/how-to-stop-vaping-for-good-bb3e0563648e

So while it doesn't occur often it doesn't take as much time to create a Pin.

Bellow you can see how much pins i have created reality paints a different picture often in life compared to what we expect.

https://pl.pinterest.com/richardtaujenis/

Branding yourself in a digital landscape has never been as competitive and saturated as it is now. While people say "you have to stand out from the rest" has never been more difficult, as when everyone is doing the same thing how to stand out?

While Pinterest may not always bring immediate results, its potential for long-term brand building is significant. Don't overlook this powerful platform in your personal branding strategy.

Effortlessly Deploy Your GCP Cloud Run App Using Terraform

Ricards Taujenis — Fri, 01 Nov 2024 14:37:15 +0000

Terraform is gaining more popularity for a reason as it provides high level of control flexibility as IaC(Infrastructure as Code)

Supports modules, keeps track of state of your infrastructure and is helpfull if your project is complex, multi-cloud or hybrid enviornments.

Prerequisites

To start off be sure to follow this guide for Terraform instalation if you haven't done so and be sure to have GCP account already set up.

You should have the app already prior deployed through other means like CLI to understand the deployment process, baseline configuration, incremental transition etc.

Related blog with manual deployment I added bellow 👇📖

https://blog.stackademic.com/how-to-deploy-a-go-service-to-gcp-cloud-run-694d01cab5b5

Project Structure

For my project structure I have these files and directory structure.

terraform/
  ├── modules/
  │   ├── docker/
  │   │   ├── docker-artifact.tf
  │   │   └── variables.tf
  │   ├── gcp/
  │   │   ├── cloud-run.tf
  │   │   └── variables.tf
  ├── main.tf
  ├── set-prod.env.sh
  ├── terraform.tfvars
  ├── variables.tf
  └── account_key.json

main.tf: Including the required providers and the Google provider configuration.
variables.tf: Describe how to define variables for your project.
terraform.tfvars: Explain how to set variable values specific to your * environment.
set-prod.env.sh: Sets the enviornment variables for terraform with TF_VAR prefix flag.
Modules: Detail the docker and cloud-run modules, explaining their roles and how they interact.

IaC Scripts

I will showcase from parent to child modules scripts for more of a higher order guide.
Most likely you will have env variables most convieneit way for me is to create shell script with the TF_VAR_ prefix that Terraform will recoginze and use ones initialized(but for that later).

#!/bin/bash

#server 
export TF_VAR_redis_url="redis_url"
export TF_VAR_firebase_account_key="your_account_key.json"
export TF_VAR_client_url="client_url"
export TF_VAR_gcp_account_key="client_url"

echo "Environment variables for Terraform GCP set."

Variables that i have as well set in module level but parent will usually contain all of them but in module level i just passed the right ones.

variable "project_id" {
  description = "The ID of the Google Cloud project."
  type        = string
}

variable "project_name" {
  description = "The project name of the Google Cloud Run project."
  type        = string
}

variable "region" {
  description = "The Google Cloud region."
  type        = string
}

variable "redis_url" {
  description = "The URL for the Redis instance."
  type        = string
}

variable "client_url" {
  description = "The URL for the client application."
  type        = string
}

variable "gcp_account_key" {
  description = "Path to the Google Cloud service account key file."
  type        = string
}

variable "firebase_account_key_location" {
  description = "Firebase account key location in Docker container."
  type        = string
}

There is as well other script file that I created that does NOT contain private or secret key values that can be easily modified and is handy for default values thats your terraform.tfvars

project_id = "recepies-6e7c0"
project_name = "recipe-service"
region     = "europe-north1"
gcp_account_key = "./account_key.json"
firebase_account_key_location = "/app/config/account_key.json"

Lets talk about 🐘 in the room our main.tf script.

terraform {
  required_providers {
    google = {
      source  = "hashicorp/google"
      version = ">= 4.0.0"
    }
  }
  required_version = ">= 0.12"
}

provider "google" {
  credentials = file(var.gcp_account_key)
  project     = var.project_id
  region      = var.region
}

# Get project information
data "google_project" "project" {
  project_id = var.project_id
}

module "docker" {
  source      = "./modules/docker"
  project_id  = var.project_id
}

module "cloud_run" {
  source      = "./modules/gcp"
  project_id  = var.project_id
  region      = var.region
  redis_url   = var.redis_url
  client_url  = var.client_url
  firebase_account_key_location = var.firebase_account_key_location
  cloudrun_image = "gcr.io/${var.project_id}/recipe-server:latest"

  depends_on = [
    module.docker
  ]
}

At the begining I define the PaaS provider as i use GCP google is added you can add AWS, Azure or other providers. Creditentials are essential to approve your request to any cloud provider the gcp_account_key you pass as a json file that i have in parent terraform directory.

At above screenshot you can see i have created a Service account key in GCP and passed the right IAM access rights.

It crucial to assign the correct IAM (Identity and Access Management) access rights to the account_key.json as otherwise you will have different permission issues when trying to run Terraform. Roles viewer, editor, storage.admin, cloudrun.admin, Docker artifacts.

There is an alternative as well to just assign roles and permission through IaC but for me it's more an hastle at least until i get more familiar with it.

gcloud projects add-iam-policy-binding YOUR_PROJECT_ID \
  --member="serviceAccount:YOUR_SERVICE_ACCOUNT_EMAIL" \
  --role="roles/editor"

Above ilustrates how it could be done.

Then next steps are running your modules I start off with docker as need to create Docker Artifact in GCP and after that is completed I do the same with Cloud Run. Keep in mind I access the dir with "./modules/docker" and pass needed variables from parent to child modules/docker/variables.tf.

resource "google_project_service" "container_registry_api" {
  project = var.project_id
  service = "containerregistry.googleapis.com"
  disable_on_destroy = false
}

resource "null_resource" "docker_build_push" {
  triggers = {
    always_run = timestamp()
  }

  provisioner "local-exec" {
    command = <<-EOT
      # Build the Docker image
      docker build -t gcr.io/${var.project_id}/recipe-server:latest .

      # Configure docker to authenticate with GCP
      gcloud auth configure-docker --quiet

      # Push the image
      docker push gcr.io/${var.project_id}/recipe-server:latest
    EOT
  }

  depends_on = [
    google_project_service.container_registry_api
  ]
}

The docker-artifact.tf is quite short as only think we need is to define the resources used starting with container_registry_api and secondly docker_build_push add provisioning for local execution and end it with building and deploying the grc docker image with passed in var.project_id + add that it depends on container_registry_api as its required.

Lastly in our IaC we deploy it running our last module with "./modules/gcp"

resource "google_project_service" "required_apis" {
  for_each = toset([
    "run.googleapis.com",
    "containerregistry.googleapis.com"
  ])

  project = var.project_id
  service = each.key
  disable_on_destroy = false
}

resource "google_cloud_run_service" "recipe_service" {
  name     = var.project_name
  location = var.region
  project  = var.project_id

  template {
    spec {
      containers {
        image = var.cloudrun_image

        env {
          name  = "REDIS_URL"
          value = var.redis_url
        }
        env {
          name  = "CLIENT_URL"
          value = var.client_url
        }
        env {
          name  = "FIREBASE_ACCOUNT_KEY"
          value = var.firebase_account_key_location
        }
      }
    }
  }

  depends_on = [
    google_project_service.required_apis
  ]
}

resource "google_cloud_run_service_iam_member" "public_access" {
  location = google_cloud_run_service.recipe_service.location
  project  = google_cloud_run_service.recipe_service.project
  service  = google_cloud_run_service.recipe_service.name
  role     = "roles/run.invoker"
  member   = "allUsers"
}

Same as for docker module we define required resources for "google_cloud_run_service" we select the name, region, project_id then select the image thats been passed from main.
If you have required env variables pass them as well.
IAM member resource is added to give permission for deployment to Cloud Run.

Deploying Your Application

Now when architecture is set and done we do the following steps.

1.Initialize Terraform

terraform init

Run the Shell Script or manually set your env variables

source set-prod.env.sh

For terraform to access the .env variables.

Preview the changes in terraform or dirrectly deploy it.

terraform plan //Helps you preview the changes that Terraform will make to your infrastructure. 

terraform apply //Run the terraform script to deploy your app through IaC.

If all is good you will end up with something like this.

If commiting to GitHub be note worthy to add some files in .gitignore as terraform generates artifacts and backup etc.

terraform/set-prod-env.sh
terraform/account_key.json
terraform/.terraform
terraform/.terraform.lock.hcl
terraform/.terraform.tfstate.lock.info

# Ignore Terraform working directory
terraform/.terraform/

# Ignore tfstate files and backups
*.tfstate
*.tfstate.backup

Conclusion

While IaC adds some complexity compared to manual setup it adds as well levarage as mentioned before of more maintainability and automation espectially of interact between multiple cloud providers etc. As well for me personally it gives more power to me as a developer!
Repo you can find here.

How to Deploy a Go service to GCP Cloud Run

Ricards Taujenis — Wed, 02 Oct 2024 15:04:32 +0000

Deploying a Go service to GCP Cloud Run involves several steps, including setting up a Dockerfile and configuring environment variables.

This guide will walk you through the process.

If you would like to follow it in video format as well have it on *YouTube *here.

Set up your GCP Project

Start off by going to GCP create account if havent done so yet.

Create a GCP Project.

Go to the GCP console and create a new project.
Note the project ID for deployment.

Enable required APIs.

Enable the Cloud Run API and Container Registry API.

Install Google Cloud SDK

Initialize your repository with gcloud init.

Create your Go Service

Ensure your Go app can run locally and set up a Dockerfile.

cmd/main.go

// cmd/main.go
func main() {
 flag.Parse()

 a := app.Application{}

 if err := a.LoadConfigurations(); err != nil {
        log.Fatalf("Failed to load configurations: %v", err)
    }

    if err := runtime.Start(&a); err != nil {
        log.Fatalf("Failed to start the application: %v", err)
    }

}

runtime/base.go

func Start(a *app.Application) error {
    router := gin.New()

    router.Use(cors.New(md.CORSMiddleware()))

    api.SetCache(router, a.RedisClient)
    api.SetRoutes(router, a.FireClient, a.FireAuth, a.RedisClient)

    err := router.Run(":" + a.ListenPort)
    log.Printf("Starting server on port: %s", a.ListenPort)
    if err != nil {
        return err
    }

    return nil
}

Create Dockerfile

# Use the official Go image as the base image
FROM golang:1.18

WORKDIR /app

# Copy the Go module files
COPY go.mod go.sum ./

RUN go mod download

# Copy the rest of the application code
COPY . .

RUN go build -o main  ./cmd/main.go

CMD ["./main"]

Set Up Env variables

Use shell script to automate setting env variables for GCP

as env-variables.sh.

// env-variables.sh
#!/bin/bash

# Environment variables
export PROJECT_ID=recepies-6e7c0
export REGION=europe-west1

export REDIS_URL="rediss://default:AVrvA....-lemur-23279.u....:6379"
export FIREBASE_ACCOUNT_KEY="/app/config/account_key.json"
export CLIENT_URL="https://.....vercel.app/"

Deployment script as deploy-with-yaml.sh.

#!/bin/bash

source env-variables.sh

#Comment if correctly deployed
docker build -t gcr.io/$PROJECT_ID/recipe-server:latest .
docker push gcr.io/$PROJECT_ID/recipe-server:latest

#Uncomment if json needs to be added to GCP 
# gcloud secrets create firebase-account-key --data-file=/mnt/c/own_dev/RecipesApp/server/config/account_key.json --project=recepies-6e7c0

#Add permission IAM
gcloud projects add-iam-policy-binding recepies-6e7c0 \
    --member="serviceAccount:service-988443547488@serverless-robot-prod.iam.gserviceaccount.com" \
    --role="roles/artifactregistry.reader"

gcloud run deploy recipe-service \
  --image gcr.io/$PROJECT_ID/recipe-server:latest \
  --region $REGION \
  --platform managed \
  --set-env-vars REDIS_URL=$REDIS_URL,CLIENT_URL=$CLIENT_URL,FIREBASE_ACCOUNT_KEY=$FIREBASE_ACCOUNT_KEY

Deployment to your GCP Cloud Run

Run the deployment script

env-variables.sh

Common Issues and Troubleshooting

Permission Issues: Ensure the Cloud Run Service Agent has permission to read the image.
Environment Variables: Verify that all required environment variables are set correctly.
Port Configuration: Ensure the PORT environment variable is set correctly.

When all set up as needed you will see Image being build and pushed to your GCP project Artifact Registry. In the end i got this.

a9099c3159f5: Layer already exists
latest: digest: sha256:8c98063cd5b383df0b444c5747bb729ffd17014d42b049526b8760a4b09e5df1 size: 2846
Deploying container to Cloud Run service [recipe-service] in project [recepies-6e7c0] region [europe-west1]
✓ Deploying... Done.
  ✓ Creating Revision...
  ✓ Routing traffic...
Done.
Service [recipe-service] revision [recipe-service-00024-5mh] has been deployed and is serving 100 percent of traffic.
Service URL: https://recipe-service-819621241045.europe-west1.run.app

There is a standart error that I came across multiple times 👇

Deploying container to Cloud Run service [recipe-service] in project [recepies-6e7c0] region [europe-west1] X Deploying… - Creating Revision… . Routing traffic… Deployment failed ERROR: 
(gcloud.run.deploy) Revision 'recipe-service-00005-b6h' 
is not ready and cannot serve traffic. Google Cloud Run Service Agent service-819621241045@serverless-robot-prod.iam.gserviceaccount.com must have permission to read the image, 
gcr.io/loyal-venture-436807-p7/recipe-server:latest. Ensure that the provided container image URL is correct and that the above account has permission to access the image. If you just enabled the Cloud Run API, the permissions might take a few minutes to propagate. Note that the image is from project [loyal-venture-436807-p7], which is not the same as this project [recepies-6e7c0]. Permission must be granted to the Google Cloud Run Service 
Agent service-819621241045@serverless-robot-prod.iam.gserviceaccount.com from this project. See https://cloud.google.com/run/docs/deploying#other-projects

Often it states that PORT=8080 could not be set but main issue is something else like env variable not set or in my case firebase account_key.json incorrectly set for deployment.

When all is set you can test the connection and do requests.

I have my frontend deployed in Vercel and bellow you can see my Cloud Run Logs

Deploying a Go service to GCP Cloud Run can be streamlined with a few key configurations and automation scripts.

Although there might be some common errors, such as permission issues or incorrect environment variables, understanding how to troubleshoot them through Cloud Run logs ensures a smooth deployment.
My repo you can find here.

gRPC Communication Between Go and Python

Ricards Taujenis — Thu, 22 Aug 2024 09:55:32 +0000

gRPC is a powerful, high-performance Remote Procedure Call (RPC) framework that, despite being less commonly used than REST, offers significant advantages in certain scenarios.

In addition it's language agnostic and can run in any environment, making it an ideal choice for server-to-server communication.

I will not delve into in whole explenation of it but here is a general link of gRPC. I'll provide a hands on turtorial

Related video you can find here: https://www.youtube.com/watch?v=BXY1-BJc3js.

Go gRPC client

Lets image our Go is client but is a server asfor frontend app React, Svelte etc.

func getFirstArg() (string, error) {
    if len(os.Args) < 2 {
        return "", fmt.Errorf("expected 1 argument, but got none")
    }
    return os.Args[1], nil
}

func main() {
    filePath, err := getFirstArg()
    if err != nil {
        log.Fatalf("Failed to get file path from arguments: %v", err)
    }

    fileData, err := ioutil.ReadFile(filePath)
    if err != nil {
        log.Fatalf("Failed to read file: %v", err)
    }

 ...
}

As an example React frontend uploads a file, Go process it but we need answers from excel we will use GPT API. While it can be done with Go, Python on the otherhand has more packages that can ease our lives like langchan_openai, pandas for excel and so forth.

Lets start with instalation of gRPC preferably in your virtualenv .venv

$ go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
$ go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
$ export PATH="$PATH:$(go env GOPATH)/bin"

Next up you should install protocol buffer in your OS can follow it here.
Let's create a proto dir where you will store your protocol buffer file I will name it as excel.proto and paste this:

syntax = "proto3";
option go_package = "client-gRPC/proto";
service ExcelService {
    rpc UploadFile(FileRequest) returns (FileResponse);
}
message FileRequest {
    string file_name = 1;
    bytes file_content = 2;
}
message FileResponse {
    bytes file_content = 1;
}

This gRPC service, ExcelService, allows clients to upload a file by sending its name and content. The server responds with the same file content.

For Go its essential to pass in go_package in Python the line is not needed.

vscode-proto3 is a good extension to download if you use VSCode.

After all of this you can generate your proto files I preffer it in same level as prot dir, for that run this command:

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative proto/excel.proto

If succesfull two files should be generated, optionally if there would be a lot of adjustments add a Makefile and define it as proto + upper command.

import (
    ....

    "google.golang.org/grpc"
    pb "client-gRPC/proto"
    "github.com/xuri/excelize/v2"
)

func main() {
    ....

    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("Failed to connect to gRPC server: %v", err)
    }
    defer conn.Close()

    client := pb.NewExcelServiceClient(conn)

    req := &pb.FileRequest{
        FileName:    filePath,
        FileContent: fileData,
    }

    res, err := client.UploadFile(context.Background(), req)
    if err != nil {
        log.Fatalf("Failed to upload file: %v", err)
    }

    outputFile := "output.xlsx"
    err = saveBytesAsExcel(outputFile, res.FileContent)
    if err != nil {
        log.Fatalf("Failed to save bytes as Excel file: %v", err)
    }

    fmt.Printf("Excel file saved as: %s\n", outputFile)
}

func saveBytesAsExcel(filePath string, fileContent []byte) error {
    f, err := excelize.OpenReader(bytes.NewReader(fileContent))
    if err != nil {
        return fmt.Errorf("failed to open Excel file: %v", err)
    }

    if err := f.SaveAs(filePath); err != nil {
        return fmt.Errorf("failed to save Excel file: %v", err)
    }
    return nil
}

We make a connection to listen to 50051 that will be our Python server, &pb.FileRequest was generated prior by using proto command and now we are importing the methods. If you run you will recive 👇 due to Python server not established yet.

Failed to upload file: rpc error: code = Unavailable desc = connection error: desc = "transport: Error while dialing: dial tcp 127.0.0.1:50051: connect: connection refused"

Python gRPC server

As python will act as a server the approach will be slightly different but in essense same proto file appart from package field is not reqired. Lets start by creating a base main.py without the gRPC just to give a glance of how GPT will populate the questions in excel.

import os
import openai
import pandas as pd
from dotenv import load_dotenv

def get_answer_from_gpt(apikey: str, question: str):
    openai.api_key = apikey
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": question}
        ]
    )
    return response['choices'][0]['message']['content'].strip()

def answer_questions_df(df: pd.DataFrame, apikey: str):
    answers = []

    for question in df.iloc[:, 0]: 
        answer = get_answer_from_gpt(apikey, question)
        answers.append(answer)
    return answers

if __name__ == "__main__":
    load_dotenv()

    openai_api_key = os.getenv("OPENAI_API_KEY", "OpenAI API key hasn't been set.")

    df = pd.read_excel('Book1.xlsx')

    df['Answer'] = answer_questions_df(df, openai_api_key

Its a simple script that will answer questions that Go will send us but the LOC is less due to dedicated openai library that makes it easier.

We start by as well adding proto dir with same file as above the option section can be removed as disccused. Install gRPC in your virtualenv preferably and follow here the instalation for proto generation I ran"

python3 -m grpc_tools.protoc --proto_path=proto --python_out=proto --grpc_python_out=proto proto/excel.proto

To be in same lvl as my proto directory remember to add __init.py!

Ones the files have been generated lets continue on.

import io
import grpc
from proto import excel_pb2_grpc as excel_grpc
from proto import excel_pb2

class ExcelService(excel_grpc.ExcelServiceServicer):
    def UploadFile(self, request, context):
        try:
            # Convert bytes to a file-like object
            file_like_object = io.BytesIO(request.file_content)

            # Load the workbook from the file-like object
            workbook = openpyxl.load_workbook(file_like_object)

            # Access the first sheet (or use appropriate logic to get the sheet you need)
            sheet = workbook.active

            # Convert the sheet to a DataFrame
            data = sheet.values
            columns = next(data)  # Get the header row
            df = pd.DataFrame(data, columns=columns)

            print("Loaded DataFrame:")
            print(df.head())

            # Ensure that the DataFrame is not empty and has questions
            if df.empty or df.shape[1] < 1:
                print("DataFrame is empty or does not have the expected columns.")
                return excel_pb2.FileResponse(file_content=b'')

            # Get answers and add them to the DataFrame
            answers = answer_questions_df(df, openai_api_key)
            df['Answer'] = answers

            # Write the updated DataFrame back to a BytesIO object
            output = io.BytesIO()
            with pd.ExcelWriter(output, engine='openpyxl') as writer:
                df.to_excel(writer, index=False, sheet_name='Sheet1')

            # Reset the buffer's position to the beginning
            output.seek(0)

            # Return the modified file content
            response = excel_pb2.FileResponse(file_content=output.read())
            return response
        except Exception as e:
            print(f"Error processing file: {e}")
            return excel_pb2.FileResponse(file_content=b'')

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    excel_grpc.add_ExcelServiceServicer_to_server(ExcelService(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    print("Server running on port 50051.")
    server.wait_for_termination()

if __name__ == "__main__":
    load_dotenv()

    openai_api_key = os.getenv("OPENAI_API_KEY", "OpenAI API key hasn't been set.")

    serve()

We define server and add ExcelService class what containes the methods generated by proto file. Because we recive file by bytes have to use io byte reader and commence further processing of the file and population the second column.

response = excel_pb2.FileResponse(file_content=output.read())

At the end we are returning ☝️ for our Go client to recive.

To be able to find proto files in python however you should define an export path

export PYTHONPATH=$PYTHONPATH:mnt/c/own_dev/gRPC/server/proto

Running Client and Server

If all is good you can run

#First comes server

python3 -m main

#Then client

go run client.go Book1.xlsx

And you should get the updated .xlsx file in Go client side.

Conclusion

In this article we explored the fundamentals of setting up gRPC communication between Python server and Go client. By leveraging gRPC, we established a seamless way to send an Excel file from a Go application to a Python server, process the file using OpenAI's GPT API, and return the modified file back to the Go client.