syntax = "proto3";

package user;

message User {
    string name = 1;
    int32 age = 2;
}

go get google.golang.org/protobuf/cmd/protoc-gen-go

protoc --go_out=. user.proto

package main

import (
    "log"
    "github.com/confluentinc/confluent-kafka-go/kafka"
    "google.golang.org/protobuf/proto"
    "your_project/user"
)

func main() {
    producer, err := kafka.NewProducer(&kafka.ConfigMap{"bootstrap.servers": "localhost:9092"})
    if err != nil {
        log.Fatal(err)
    }
    defer producer.Close()

    // create user
    user := &user.User{
        Name: "Alice",
        Age:  30,
    }

    // serialize data
    data, err := proto.Marshal(user)
    if err != nil {
        log.Fatal("Failed to serialize user:", err)
    }

    // publish a message
    topic := "users"
    err = producer.Produce(&kafka.Message{
        TopicPartition: kafka.TopicPartition{Topic: &topic, Partition: kafka.PartitionAny},
        Value:          data,
    }, nil)

    if err != nil {
        log.Fatal("Failed to send message:", err)
    }

    producer.Flush(15 * 1000)
    log.Println("User sent to Kafka:", user.Name)
}

package main

import (
    "log"
    "github.com/confluentinc/confluent-kafka-go/kafka"
    "google.golang.org/protobuf/proto"
    "your_project/user"
)

func main() {
    consumer, err := kafka.NewConsumer(&kafka.ConfigMap{
        "bootstrap.servers": "localhost:9092",
        "group.id":          "user_group",
        "auto.offset.reset": "earliest",
    })
    if err != nil {
        log.Fatal(err)
    }
    defer consumer.Close()

    consumer.SubscribeTopics([]string{"users"}, nil)

    for {
        msg, err := consumer.ReadMessage(-1)
        if err != nil {
            log.Println("Error reading message:", err)
            continue
        }

        // deserialization
        receivedUser := &user.User{}
        if err := proto.Unmarshal(msg.Value, receivedUser); err != nil {
            log.Println("Failed to unmarshal user:", err)
            continue
        }

        // use info
        log.Printf("Received User: Name: %s, Age: %d\n", receivedUser.Name, receivedUser.Age)
    }
}

docker-compose up -d

pip install redis

import json

from redis import StrictRedis


server = StrictRedis(host="localhost", port=6399, password="redis_password", db=0)

# redis ping
print(server.ping())

topic = "example_topic"

data = {
    "name": "alireza",
    "age": 22,
}

server.publish(channel=topic, message=json.dumps(data))

import json

from redis import StrictRedis


client = StrictRedis(host="localhost", port=6399, password="redis_password", db=0)

topic = "example_topic"

pubsub = client.pubsub()

pubsub.subscribe(topic)

print("waiting for message...")

while True:
    for message in pubsub.listen():
        if message["data"] == 1:
            continue
        match message["type"]:
            case topic:
                # TODO - change serialization. json is not good
                data = json.loads(message["data"])
                print("received message", data["name"], data["age"])

{"alg": "HS256"}

{"user_id": 1, "exp": 111222558}

   header.payload
   

   header.payload.signature

package main

import (
"fmt"
"net/http"
"github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
  CheckOrigin: func(r *http.Request) bool {
    // checking conditions
    return true
  },
}

func handleConnections(w http.ResponseWriter, r *http.Request) {
  // upgrade http request to websocket
  ws, err := upgrader.Upgrade(w, r, nil)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer ws.Close()

  // messages
  for {
    messageType, msg, err := ws.ReadMessage()
    if err != nil {
      fmt.Println(err)
      break
    }
    fmt.Printf("Received: %s\n", msg)

    err = ws.WriteMessage(messageType, msg)
    if err != nil {
      fmt.Println(err)
      break
    }
  }
}

func main() {
  http.HandleFunc("/", handleConnections)
  fmt.Println("Server started on :8080")
  err := http.ListenAndServe(":8080", nil)
  if err != nil {
    fmt.Println("Error starting server:", err)
  }
}

https://accounts.google.com/o/oauth2/v2/auth?client_id=YOUR_CLIENT_ID&redirect_uri=YOUR_REDIRECT_URI&response_type=code&scope=email%20profile

POST https://oauth2.googleapis.com/token

{
  "code": "CODE_RECEIVED_FROM_GOOGLE",
  "client_id": "YOUR_CLIENT_ID",
  "client_secret": "YOUR_CLIENT_SECRET",
  "redirect_uri": "YOUR_REDIRECT_URI",
  "grant_type": "authorization_code"
}

GET https://www.googleapis.com/oauth2/v2/userinfo
Authorization: Bearer ACCESS_TOKEN

FROM python:3.11-slim as builder

# avoid stuck build due to user prompt
ARG DEBIAN_FRONTEND=noninteractive

RUN apt-get update && \
    apt-get install -y --no-install-recommends ...

# create and activate virtual environment
RUN python -m venv /home/myuser/venv
ENV PATH="/home/myuser/venv/bin:$PATH"

# install requirements
COPY ./requirements .
RUN pip3 install --upgrade --no-cache-dir pip
RUN pip3 install --no-cache-dir wheel
RUN pip3 install --no-cache-dir -r production.txt

FROM python:3.11-slim

RUN useradd --create-home myuser
COPY --from=builder /home/myuser/venv /home/myuser/venv

USER myuser
RUN mkdir /home/myuser/code
WORKDIR /home/myuser/code
COPY . /home/myuser/code

EXPOSE $DJANGO_PORT

# make sure all messages always reach console
ENV PYTHONUNBUFFERED=1

# activate virtual environment
ENV VIRTUAL_ENV=/home/myuser/venv
ENV PATH="/home/myuser/venv/bin:$PATH"

# /dev/shm is mapped to shared memory and should be used for gunicorn heartbeat
# this will improve performance and avoid random freezes
# CMD ["gunicorn","-b", "0.0.0.0:8000", "-w", "4", "-k", "gevent", "--worker-tmp-dir", "/dev/shm", "--chdir", "config config.wsgi:application"]