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. 😉

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.

How to Stop Vaping for GoodEasy steps on how to stop your cravings on vapingrichard-taujenis.medium.com

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.

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

2. Run the Shell Script or manually set your env variables

source set-prod.env.sh

For terraform to access the .env variables.

3. 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.

This guide will walk you through the process.

Set up your GCP Project

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

1. Create a GCP Project.

• Go to the GCP console and create a new project.

• Note the project ID for deployment.

2.Enable required APIs.

• Enable the Cloud Run API and Container Registry API.

3.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

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

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 pathexport 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.

Advertisments are everywhere in todays digital landscape, from websites, apps, and even streaming services. Taking matters in own hands by blocking ads and tracking scripts, setting up your own ad blocker with a Raspberry Pi is a great way to start. Appart from the project that will help you manage ads, but it also offers a hands on way to learn about Internet of Things (IoT).

How does it work?

We will use Pi-hole it’s a popular tool that acts as a network-wide ad blocke by functioning as a DNS sinkhole. In a nutshell Pi-hole interecentps DNS requests and blocks these that match known ad and tracking domains.

DNS (Domain Name System): DNS is like the phonebook of the internet. Basically it translates names like www.google.com into IP address

• Primary DNS (IPv4): 8.8.8.8

• Secondary DNS (IPv4): 8.8.4.4

**DHCP (Dynamic Host Configuration Protocol): DHCP **is a network management protocol to automatically asign IP addresses and other network configurations.

The diagram bellow hope is clarrifing enough how it will work.

Setting Up Your Raspberry Pi

For the setup, it’s advisable to use Raspberry Pi OS Lite, which is a minimal version of the Raspberry Pi operating system.

1. Install Raspberry Pi OS Lite and connect your Raspberry Pi to your router.

2 .Set a Static IP Address:

• SSH into your Raspberry Pi using the command: ssh pi@<your_pi_ip_address>.

• Edit the DHCP configuration by running sudo nano /etc/dhcpcd.conf.

• Set your desired static IP address, ensuring it’s within the range provided by your router’s DHCP settings.

• Save the changes and reboot the Raspberry Pi using sudo reboot.

When connecting on ethernet you wont know your IP address unless search it in router admin LAN devices. 👇

The DHCP configurations better to enable just one as wlan0 is not needed in my case to not cause conflicts.

Installing Pi-Hole

Installing Pi-Hole is straightforward. Simply run the following command in your terminal:

curl -sSL https://install.pi-hole.net | bash

The listed command will start the Pi-hole installatio script. Just follow screen prompts to complete the setup process. For a detailed walkthrough pick up the video listed here at the 4:08 mark.

Important Note on DNS Configuration

After installing Pi-Hole, you may notice that your devices are not immediately routing traffic through it. This is because, by default, devices on your network continue to use the DNS server provided by your router, which is often your ISP’s DNS or a service like Google DNS.

Few things to consider:

• Delayed Configuration: If your router’s DHCP is set to manual mode (meaning it’s not automatically updating DNS settings), your devices may take some time to start using Pi-Hole as their DNS server. This can be due to DHCP leases needing to expire and refresh with the new DNS settings.

• Manual DNS Setting: If you don’t want to wait, you can manually configure your devices to use the Pi-Hole as their DNS server. On Windows, for example, you can do this by going to your network settings and entering the IP address of your Raspberry Pi as the DNS server.

Manual setup you can see being done bellow on Windows device same can be done on OS if patience is not your strong suite.

Accessing the Pi-Hole Dashboard

Once everything is set up, you can access the Pi-Hole web interface to manage your network settings and view blocked requests.

http://192.168.1.74/admin/

Raspberry PI while being small can be a powwerfull tool ranging from setting up NAS (Network-Attached Storage) , VPN or even delve into basic electronics projects. These are just a few of many ways to expand your knowledge of IoT (Internet of Things) with this versatile device.

With Pi-Hole running, you should see a significant reduction in ads across your network, and you’ll have greater control over your DNS settings — no need to rely on Google’s or Microsoft’s default configurations.

Redis is an in memory data structure store often used as a cache and message broker but can as well be used as a primary database.

Redis is well suited for JWT authentication tokens due to Speed, Scalability, TTL(Time To Live), Session Storage.

I will use own repository to showcase how have I used it and if you want to follow video format you can check out bellow YouTube videos.

Introduction

In JWT authentication like mine it makes sense if you have a primary database like PostgreSQL, Mongo or Firebase(like in my example).

Be sure to run command

go get github.com/redis/go-redis/v9

Ones installed figure out if you want to run Redis in a Docker Image or PaaS provider like Upstash👇

https://console.upstash.com/login

You can use Docker to run Redis.

docker run — name recepie -p 6379:6379 -d redis:latest

In a nutshell my frontend is with React but backend is Go with Gin Web Framework main database Firebase and Redis will save userID with AuthToken ones logged in from frontend.

Architecture & Code

Architecures change based on implementation This is how I have approached it to make it organized.

Application Configuration

LoadConfigurations: Set up initial configurations, including connecting to Firebase and Redis.

func (a *Application) LoadConfigurations() error {
 ctx := context.Background()

 fireClient, err := GetFirestoreClient(ctx)
 if err != nil {
  return err
 }
 a.FireClient = fireClient

 fireAuth, err := GetAuthClient(ctx)
 if err != nil {
  return err
 }
 a.FireAuth = fireAuth

 // Redis env variable depending if PaaS server provided if not 6379 port used. 
 // So basically Docker image.
 a.RedisPort = envy.Get("REDIS_SERVER", "localhost:6379")

 redisClient, err := RedisConnect(a.RedisPort)
 if err != nil {
  return err
 }

 a.RedisClient = redisClient

 a.ListenPort = envy.Get("PORT", "8080")

 return nil
}

RedisConnect Function: Connect to Redis, handling both Docker and PaaS setups

func redisClientPort(port string, envExists bool) (*redis.Client, error) {
    if envExists {
       opt, err := redis.ParseURL(port)
       if err != nil {
          return nil, fmt.Errorf("failed to parse Redis URL: %w", err)
       }
       return redis.NewClient(opt), nil
    }

    return redis.NewClient(&redis.Options{
       Addr:     port,
       Password: "",
       DB:       0,
    }), nil
}

func RedisConnect(port string) (*redis.Client, error) {
    _, ok := os.LookupEnv(port)
    client, err := redisClientPort(port, ok)
    if err != nil {
       return nil, fmt.Errorf("failed to ping Redis server: %w", err)
    }

    ping, err := client.Ping(context.Background()).Result()
    if err != nil {
       return nil, fmt.Errorf("failed to ping Redis server: %w", err)
    }

    fmt.Println("Ping response from Redis:", ping)
    return client, nil
}

Start Function: Initialize the Gin router and set up routes and middleware.

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)
    if err != nil {
       return err
    }

    return nil
}

SetCache Function: Define endpoints for setting cache and other requests handled by Firebase.

// api/controller.go
func SetCache(router *gin.Engine, client *redis.Client) {
    router.POST("/set-cache", func(c *gin.Context) {
       setUserCache(c, client)
    })

    router.GET("/check-expiration", func(c *gin.Context) {
       checkTokenExpiration(c, client)
    })

}

func SetRoutes(router *gin.Engine, client *firestore.Client, auth *auth.Client, redisClient *redis.Client) {
    router.OPTIONS("/*any", func(c *gin.Context) {
       c.Status(http.StatusOK)
    })
    
    // In Gin Use means that it's required
    router.Use(func(c *gin.Context) {
       authToken := getUserCache(c, redisClient)
       md.AuthJWT(auth, authToken)(c)
    })

    router.GET("/", func(c *gin.Context) {
       showRecepies(c, client)
    })

    router.POST("/", func(c *gin.Context) {
       addRecepie(c, client)
    })

In SetRouters we do main requests to alter db data. AuthJWT is set by client side on Firebase to authenticate any request made to database.

AuthToken is what we will be talking about and it is passed in to AuthJWT to authenticate or deny user of any interaction.

Next up is to set up main GET, SET actions including TTL for session management.

// models/cache.go
type UserCache struct {
    UserID    string `redis:"UserID"`
    AuthToken string `redis:"AuthToken"`
}

The above struct is the only important one to parse incoming data from React. ☝️

Handling Cache Operations

Get User Cache: Retrieve user cache from Redis.

// api/cache.go
func getUserCache(ctx *gin.Context, client *redis.Client) string {
    userID := ctx.Query("userID")
    authToken, err := models.GetUserCacheToken(ctx, client, userID)
    if err != nil {
       log.Printf("Issues retriving  Cached Token %v", err)
       return ""
    }

    return authToken
}

// models/cache.go
func GetUserCacheToken(ctx *gin.Context, client *redis.Client, userID string) (string, error) {
 key := fmt.Sprintf("user:%s", userID)
 cache, err := client.HGetAll(ctx, key).Result()
 if err != nil {
  return "", fmt.Errorf("failed to get cache: %v", err)
 }

 authToken, ok := cache["AuthToken"]
 if !ok {
  return "", fmt.Errorf("AuthToken not found in cache")
 }

 return authToken, nil
}

Set User Cache: Set user cache in Redis with TTL.

// api/cache.go
func setUserCache(ctx *gin.Context, client *redis.Client) {
    var userCache models.UserCache

    err := models.UnmarshallRequestBodyToAPIData(ctx.Request.Body, &userCache)
    if err != nil {
       ctx.JSON(http.StatusBadRequest, gin.H{
          "error": "Unable to parse data",
       })
       return
    }

    key := fmt.Sprintf("user:%s", userCache.UserID)
    _, notExists := client.HGetAll(ctx, key).Result()

    if notExists == nil {
       userCache.SetCachedToken(ctx, client, key)
       return
    }

}

// models/cache.go

func (c *UserCache) SetCachedToken(ctx *gin.Context, client *redis.Client, key string) {
 fields := map[string]interface{}{
  "UserID":    c.UserID,
  "AuthToken": c.AuthToken,
 }
 err := client.HSet(ctx, key, fields).Err()
 if err != nil {
  log.Printf("Issues setting Cached Token %v", err)
 }

 client.Expire(ctx, key, 7*24*time.Hour)

}

If you are interested in React section let me know otherwise Github repo will be listed bellow.

As on React login through Firebase it creates a user with authToken and passes to Go backend if exists ignore otherwise create.

Check Token Expiration

Check Token Expiration: Check if the token has expired.

// api/cache.go
func checkTokenExpiration(ctx *gin.Context, client *redis.Client) {
    userID := ctx.Query("userID")
    key := fmt.Sprintf("user:%s", userID)

    ttl, err := client.TTL(ctx, key).Result()
    if err != nil {
       ctx.JSON(http.StatusInternalServerError, gin.H{
          "error": "Failed to get TTL",
       })
       return
    }

    expired := ttl <= 0

    ctx.JSON(http.StatusOK, expired)
}

Conclusion

This setup provides a robust structure for managing JWT authentication with Redis in a Go application, ensuring efficient session management and token validation. If there are any questions feel free to ask(or ask GPT) my repo you can find bellow.

https://github.com/Mozes721/RecipesApp

The thumbnail perfectly describes reason why meditation is crucial in our day in age. With the rapid advancements in AI and technology, thinking for ourselves can feel impossible as we are constantly bombarded with information and distractions. This is where meditation becomes crucial.I found myself in need of a mental reset.

The Importance of Meditation Today

As a developer and someone who works behind the screen more then 8h a day(95% of people here do I pressume) Meditation offered a quick, effecive reset and clarity(even euphoria if done consistently).

Stress reduction: In an 8-week study, a meditation style called "mindfulness meditation" reduced the inflammation response caused by stress

Controls anxiety: Meditation can reduce stress levels, which translates to less anxiety as well help control job-releated anxiety(something needed in our day and age). FYI almost everyone now suffers from ADHD and it's not out of nowhere.

Enhances self-awareness: Can help you develop a stronger understanding of yourself with how it is currently heading it is mitigated strongly.

Lengthens attention span: Focused-attention meditation is like weight lifting for your attention span. It helps increase the strength and endurance of your attention.

Many more advantages but I will not get further into it for but more of can find here.

To put it shortly connecting with yourself and not being influenced by external factors has been harder then ever and may link to depresion and anxiety. With regular meditation may it be 10 min can give a high level of euphoria and mindfullness.

How to Meditate

It's not an overall cure but it can provide the mental space needed to listen to your inner self and resist external pressures. It's easy getting "roped in" by external factors(like raise your exepctations to unresonable amounts based on Instagram stories or YouTube or some course that sells you high success rate of completion).

Taking time off for yourself will lead to greater productivity. Same as going to gym for physical health that will increase your mood and make you tackle professional chalanges at work etc so will having mental clarity and being mindfull. Appart from the obvious of getting into it 🧘‍♂️👇

• Take a Seat: Find a comfortable place to sit.

• Set a Time Limit: Start with just 10 minutes.

• Notice Your Body: Make sure you're comfortable and stable.

• Feel Your Breath: Focus on your breathing.

• Notice When Your Mind Wanders: It's natural for your mind to wander. Simply bring it back to your breath.

• Be Kind to Your Wandering Mind: Don't judge yourself for getting distracted.

• Close with Kindness: End your session with a moment of gratitude or kindness.

As a begginer guided meditation is what I would strongly recomend on YouTube bellow I added my favorite guide.

Consistency is key so no reason to be hard on yourself if it wont go smoothly initially or you wonder off.

In the fast-paced world of IT, it's easy to feel overwhelmed and suffer from issues like ADHD and impatience.

Without clarity and self control it's difficult to continuously make good decisions without emotions taking over AI worsens it even if technology is superb.

Taking time for yourself through meditation can lead to greater productivity and a more balanced life. Give it a try and see the difference it can make.

As Web3 becomes more streamlined and decentralized app development increases, the need for lightning-fast gateway providers to decentralized blockchain data also grows. Nodies addresses this need by offering efficient and reliable access to blockchain data.

How does Nodies archive it?

In a nutshell Nodies is part of an ongoing partnership with the Pocket Network Foundation more you can find here. It has implemented public RPC endpoints utilizing the Pocket Network's decentralized infrastructure for relaying RPC requests.

Remote Procedure Call (RPC): A protocol that enables one program to execute a procedure or service in another program on a different machine within a network. In Blockchain it facilitates communication and data exchange between nodes, clients, and servers in the blockchain network.

Integrate Nodies to your NextJS dapp

As a quick setup will create a barebone wallet connect using 'wagmi' package including RPC URL provided by Nodies.

Lets start creating bare 🦴 NextJs app with

npx create-next-app@latest

Then just follow the guide from Family ConnectKit docs here.

const config = createConfig(
  getDefaultConfig({
    chains: [mainnet, polygon, avalanche],
    transports: {
      [mainnet.id]: http(
        `https://lb.nodies.app/v1/5e9daed367d1454fab7c75f0ec8aceff`, //Add here!
      ),
    },

    walletConnectProjectId: process.env.NEXT_PUBLIC_WALLETCONNECT_PROJECT_ID as string,

    appName: "Get started with Nodie powered by POKT",
    appDescription: "Walllet Connect with Nodie",
    appUrl: "https://family.co",
    appIcon: "https://family.co/logo.png",
  }),
);

From Web3Provider.tsx example add your preffered networks like polygon, avalance etc and inside transport config pass in nodies HTTP link.

The site you can reach here on the left side you just copy endpoint link and paste it. The right side is when you log in with Github can have added features like logs, statisitcs add API keys and even Websockets comming soon! 😉

Note: Be sure to add your .env file and WalletConnect Project ID follow this link to create an account and to generate projectId key.

When all set and done with the short guide referenced above you should see something like this when connected.

If you encountered issues with NextJS(I sure had) bellow I have attached dead simple repo including everything above(excluding .env duhhh)

https://github.com/Mozes721/WalletConnect

Honorable Mentions

If you want something even more flexible and additional features like utilizing your backend to your Dapp you can go up a notch using

https://docs.grove.city/guides/getting-started/welcome-to-grove

As a Go, Rust enthusiast it’s tough to ignore the added features at Groove as well powered by POKT but have utilize added features when needed.

There are several free RPC endpoints available, which vary in accessibility, user experience (UX), and performance.

The setup was quite simple and intuitive, making it relatively easy to build on top of them. This is beneficial for web3, DePIN infrastructure, or any projects that involve working with blockchain data and creating API endpoints.

If you encounter issues or have any questions feel free to contact me dirrectly or ask in discord group here.

For more on POKT Network you can check out bellow link. 👇

https://pokt.network/blog