सर्वर रहित आर्किटेक्चर:एडब्ल्यूएस लैम्ब्डा, अपस्टैश रेडिस और स्केलेबल, लागत प्रभावी ऐप्स के लिए जाएं

परिचय

1. मूल्य निर्धारण के अनुसार भुगतान करें . मैं प्रति घंटे या प्रति नोड के हिसाब से भुगतान नहीं करना चाहता, बल्कि उपयोग (अनुरोध, भंडारण, आदि) के आधार पर भुगतान करना चाहता हूं। इसका उपयोग शुरू करना बहुत सस्ता होना चाहिए और जैसे-जैसे उपयोग बढ़ेगा लागत आनुपातिक रूप से बढ़ेगी।
2. कम विलंबता . किसी को भी धीमी प्रतिक्रिया पसंद नहीं है, इसलिए डेटाबेस को क्वेरी करना AWS क्षेत्रों के अंदर से तेज़ होना चाहिए (उदाहरण के लिए eu-west-1 ).
3. उत्कृष्ट डेवलपर अनुभव (DevX) . किसी अन्य विशिष्ट डीएसएल को सीखे बिना, या किसी वेबसाइट पर घंटों बर्बाद किए बिना डेटाबेस के लिए एक अच्छा इंटरफ़ेस रखना प्राथमिकता है।

• जाते ही भुगतान करें?
  • ✅ शुरू करना वास्तव में किफायती है, और बड़े पैमाने पर भी!
• कम विलंबता?
  • ✅ < AWS Lambda के अंदर से क्वेरी करने पर 1ms विलंबता!
• महान DevX?
  • ✅ यह मानक रेडिस है। तो, हाँ.

हम क्या कार्यान्वित कर रहे हैं?

1. द GET|POST /login समापन बिंदु जो userId स्वीकार करता है GET में एक क्वेरी पैरामीटर के रूप में , या POST के साथ सबमिट किए गए फॉर्म मान के अंदर अनुरोध. यह समापन बिंदु एक सत्र आईडी उत्पन्न करेगा, इसे रेडिस में संग्रहीत करेगा, और बाद की यात्राओं के लिए एक कुकी भी सेट करेगा। GET इससे परीक्षण करना आसान हो जाता है।🙃
2. द GET /lessons/completed एंडपॉइंट के लिए लॉग इन उपयोगकर्ताओं की आवश्यकता होती है (अर्थात सत्र आईडी के साथ कुकी होना) और उपयोगकर्ता द्वारा पूरा किए गए सभी पाठों और कब पूरा हुआ, इसके साथ एक JSON प्रतिक्रिया देता है।
3. द POST /lessons/{lessonSlug}/mark-complete एंडपॉइंट के लिए लॉग इन उपयोगकर्ताओं की आवश्यकता होती है (अर्थात सत्र आईडी के साथ कुकी होना) और lessonSlug द्वारा दर्शाए गए पाठ को चिह्नित करता है जैसा कि वर्तमान समय के साथ पूरा हुआ।

1. सेटअप

• नीचे विस्तृत पूरा कोड मेरे aws-playground में भी मौजूद है रिपॉजिटरी यदि आप यह देखना चाहते हैं कि सब कुछ एक साथ कैसे फिट बैठता है।

1.1 कार्यक्षेत्र

1. गो डाउनलोड करें।
2. अपनी पसंद के क्षेत्र में एक अपस्टैश रेडिस खाता और डेटाबेस बनाएं। आदर्श रूप से यह वही AWS क्षेत्र होना चाहिए जहां आप अपना लैम्ब्डा तैनात करेंगे। मैं eu-west-1 का उपयोग करूंगा (यूरोप, आयरलैंड) इस लेख में।

mkdir -p ~/dev/aws-lambda-upstash-redis
cd ~/dev/aws-lambda-upstash-redis

go mod init com.upstash/example/aws-lambda-upstash-redis

1.2 स्थानीय सर्वर एंट्रीपॉइंट

• निम्नलिखित कोड को ~/dev/aws-lambda-upstash-redis/cmd/server/main.go में चिपकाएँ .

package main
 
import (
 "log"
 "net/http"
 "os"
 
 "com.upstash/example/aws-lambda-upstash-redis/core"
)
 
func main() {
 mux := core.NewMux()
 port := os.Getenv("PORT")
 if len(port) == 0 {
 port = "5000"
 }
 if err := http.ListenAndServe(":"+port, mux); err != nil {
 log.Fatal(err)
 }
}

1.3 AWS लैम्ब्डा एंट्रीपॉइंट

• निम्नलिखित कोड को ~/dev/aws-lambda-upstash-redis/cmd/lambda/main.go में चिपकाएँ .

package main
 
import (
 "com.upstash/example/aws-lambda-upstash-redis/core"
 "github.com/aws/aws-lambda-go/lambda"
 "github.com/awslabs/aws-lambda-go-api-proxy/httpadapter"
)
 
func main() {
 mux := core.NewMux()
 lambda.Start(httpadapter.NewV2(mux).ProxyWithContext)
}

1.4 मूल तर्क

• निम्नलिखित कोड को ~/dev/aws-lambda-upstash-redis/core/lib.go में चिपकाएँ .

package core
 
import (
 "github.com/go-chi/chi/v5"
)
 
func NewMux() *chi.Mux {
 r := chi.NewRouter()
 return r
}

1.5 निर्माण/संकलन

default: build
 
clean:
 rm -rf build/
 
build: build-lambda build-server
 
build-lambda: clean
 GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -o build/handler cmd/lambda/main.go
 cd build/ && zip handler.zip ./handler
 
build-server: clean
 CGO_ENABLED=0 go build -o build/server cmd/server/main.go

• make build-server :सर्वर को स्थानीय रूप से चलाने के लिए बाइनरी बनाता है (निष्पादन योग्य ./build/server ).
• make build-lambda :AWS Lambda (निष्पादन योग्य ./build/handler) पर सर्वर चलाने के लिए बाइनरी बनाता है और ./build/handler.zip ).
• make या make build दोनों करता है.

2. एपीआई कार्यान्वयन

import (
 //...
 "github.com/go-chi/chi/v5"
 "github.com/go-chi/chi/v5/middleware"
)
 
func NewMux() *chi.Mux {
 r := chi.NewRouter()
 
 r.Use(middleware.RequestID)
 r.Use(middleware.Logger)
 r.Use(middleware.Recoverer)
 
 r.Get("/login", login)
 r.Post("/login", login)
 r.Group(func(r chi.Router) {
 r.Use(UsersWithSessionOnly)
 r.Get("/lessons/completed", listLessonsCompleted)
 r.Post("/lessons/{lessonSlug}/mark-complete", markLessonComplete)
 })
 
 return r
}

2.1 UsersWithSessionOnly मिडलवेयर

1. उस कुकी को निकालें जिसमें सत्र आईडी है, और अन्यथा विफल हो जाएं।
2. सत्र आईडी के आधार पर उपयोगकर्ता विवरण लाने के लिए रेडिस को क्वेरी करें, और यदि प्रदान की गई सत्र आईडी सक्रिय नहीं है तो विफल हो जाती है।
3. उपयोगकर्ता आईडी को अनुरोध के context.Context में संग्रहीत करें इसे डाउनस्ट्रीम मिडलवेयर या हैंडलर्स के लिए उपलब्ध कराने के लिए।

import (
 //...
 "log"
 "os"
 "strings"
 
 "github.com/go-redis/redis/v8"
)
 
type contextKey struct {
 name string
}
const (
 COOKIE_AUTH_NAME = "xxx_session_id"
)
var (
 CTX_USER_ID = &contextKey{"LoggedInUserId"}
 redisDb = NewClient()
)
 
func NewClient() *redis.Client {
 redisUrl := strings.TrimSpace(os.Getenv("UPSTASH_REDIS_URL"))
 if redisUrl == "" {
 log.Fatalln("Required env UPSTASH_REDIS_URL not set!")
 }
 opt, _ := redis.ParseURL(redisUrl)
 redisDb := redis.NewClient(opt)
 
 return redisDb
}

// UsersWithSessionOnly middleware restricts access to just logged-in users.
// If validation passes, then the context will contain the user id (CTX_USER_ID).
func UsersWithSessionOnly(next http.Handler) http.Handler {
 return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 c, err := r.Cookie(COOKIE_AUTH_NAME)
 if err != nil {
 render.Status(r, http.StatusForbidden)
 render.JSON(w, r, struct{}{})
 return
 }
 
 ctx := r.Context()
 userId, err := redisDb.Get(ctx, "session:"+c.Value).Result()
 if err == redis.Nil {
 // If session is not found then user is forbidden from accessing the API!
 render.Status(r, http.StatusForbidden)
 render.JSON(w, r, struct{}{})
 return
 } else if err != nil {
 // Something went wrong querying Redis!
 render.Status(r, http.StatusInternalServerError)
 render.JSON(w, r, struct{ Message string }{Message: "We could not validate the provided session ID"})
 return
 }
 // Set it for downstream middleware and handlers.
 next.ServeHTTP(w, r.WithContext(context.WithValue(ctx, CTX_USER_ID, userId)))
 })
}

2.2 मार्कलेसनकंप्लीट(...)

func markLessonComplete(w http.ResponseWriter, r *http.Request) {
 ctx := r.Context()
 lessonSlug := chi.URLParam(r, "lessonSlug")
 userId := r.Context().Value(CTX_USER_ID).(string)
 timeNow := time.Now().Format(time.RFC3339)
 
 err := redisDb.HSet(ctx, "lessons:"+userId, lessonSlug, timeNow).Err()
 if err != nil {
 render.Status(r, http.StatusInternalServerError)
 render.JSON(w, r, struct{ Message string }{Message: "We could not save your progression..."})
 return
 }
 
 render.JSON(w, r, struct {
 LessonSlug string
 LastCompleted string
 }{
 lessonSlug,
 timeNow,
 })
}

2.3 सूचीपाठ पूर्ण(...)

func listLessonsCompleted(w http.ResponseWriter, r *http.Request) {
 ctx := r.Context()
 userId := r.Context().Value(CTX_USER_ID).(string)
 
 lessons, err := redisDb.HGetAll(ctx, "lessons:"+userId).Result()
 if err == redis.Nil {
 lessons = map[string]string{}
 } else if err != nil {
 render.Status(r, http.StatusInternalServerError)
 render.JSON(w, r, struct{ Message string }{Message: "We could not load your lessons..."})
 return
 }
 
 render.JSON(w, r, struct {
 Lessons map[string]string
 }{
 lessons,
 })
}

2.4 लॉगिन(...)

import (
 // ...
 "github.com/segmentio/ksuid"
)
 
func login(w http.ResponseWriter, r *http.Request) {
 // Check credentials and update redis session and return Set-Cookie
 // WARNING: You should do an actual validation in production for credentials!
 // ...
 // For now we always assume correctness and automatically create a session token
 // by saving it to Redis, and also setting it as a cookie.
 userId := strings.TrimSpace(r.FormValue("userId"))
 if userId == "" {
 render.Status(r, http.StatusBadRequest)
 render.JSON(w, r, struct{ Message string }{Message: "Missing required userId"})
 return
 }
 
 sessionId := ksuid.New()
 redisDb.Set(r.Context(), "session:"+sessionId.String(), userId, time.Hour*1)
 http.SetCookie(w, &http.Cookie{
 Name: COOKIE_AUTH_NAME, Value: sessionId.String(),
 Path: "/", MaxAge: int((time.Hour * 1).Seconds()),
 // This should be true when deploying in production (https), but locally we need it false (http).
 Secure: false,
 })
 
 http.Redirect(w, r, "/lessons/completed", http.StatusTemporaryRedirect)
}

3. डेमो - स्थानीय रूप से

• सबसे पहले, UPSTASH_REDIS_URL सेट करें उपरोक्त अनुभाग 1 में आपके द्वारा बनाए गए डेटाबेस के यूआरएल में पर्यावरण चर। आप इसे विवरण में पा सकते हैं आपके डेटाबेस के पृष्ठ का टैब (ऊपर अनुभाग 1.1 देखें)।

export UPSTASH_REDIS_URL="<your-url-here>"

• फिर, स्थानीय सर्वर बनाएं और चलाएं:

make build-server && ./build/server

ब्राउज़र परीक्षण

await (
 await fetch("http://localhost:5000/lessons/123/mark-complete", {
 method: "POST",
 credentials: "same-origin",
 })
).json();
 
// Should output something like:
// {LessonSlug: '123', LastCompleted: '2022-10-12T02:01:14+03:00'}

{ "Lessons": { "123": "2022-10-12T02:01:14+03:00" } }

4. AWS लैम्ब्डा

• <पी> सबसे पहले, SAM cli सेटअप करें और सुनिश्चित करें कि आपके उपयोगकर्ता/भूमिका के पास सही अनुमतियाँ हैं।

• <पी> sam सीएलआई को काम करने के लिए क्लाउडफॉर्मेशन टेम्पलेट की आवश्यकता है, इसलिए निम्नलिखित को aws-iac/sam-template.yml में कॉपी करें :

AWSTemplateFormatVersion: "2010-09-09"
Transform: AWS::Serverless-2016-10-31
Description: Defines all the AWS resources we need for our Upstash Redis API.
 
Resources:
 # https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html
 GoUpstashRedis:
 Type: AWS::Serverless::Function
 Properties:
 CodeUri: ../build/handler.zip
 Handler: handler
 Runtime: go1.x
 MemorySize: 512
 FunctionUrlConfig:
 AuthType: NONE
 Cors:
 AllowCredentials: false
 AllowMethods: ["*"]
 AllowOrigins: ["*"]
 
Outputs:
 GoUpstashRedisApi:
 Description: "Endpoint URL"
 Value: !GetAtt GoUpstashRedisUrl.FunctionUrl
 GoUpstashRedis:
 Description: "Lambda Function ARN"
 Value: !GetAtt GoUpstashRedis.Arn
 GoUpstashRedisIamRole:
 Description: "Implicit IAM Role created for GoUpstashRedis"
 Value: !GetAtt GoUpstashRedisRole.Arn

• AWS Lambda के लिए हैंडलर बंडल बनाएं:

make build-lambda

• निम्नलिखित को makefile में जोड़ें कोड परिवर्तन करने के बाद इसे तैनात करना आसान बनाने के लिए:

sam-deploy: build-lambda
 sam deploy -t aws-iac/sam-template.yml --stack-name "UpstashRedisGoArticleStackDemo" --region eu-west-1 --resolve-s3 --no-confirm-changeset --no-fail-on-empty-changeset --capabilities CAPABILITY_IAM CAPABILITY_NAMED_IAM CAPABILITY_AUTO_EXPAND

• निर्दिष्ट क्षेत्र में तैनात करें (पिछला आदेश देखें)।

make sam-deploy

• आपको नीचे जैसा कुछ आउटपुट मिलना चाहिए:

CloudFormation outputs from deployed stack
-----------------------------------------------------------------------------------------------------------------------------------------------------------
Outputs
-----------------------------------------------------------------------------------------------------------------------------------------------------------
Key GoUpstashRedis
Description Lambda Function ARN
Value arn:aws:lambda:eu-west-1:<redacted>:function:UpstashRedisGoArticleStackDem-GoUpstashRedis-baB8dQPkTfg0
 
Key GoUpstashRedisIamRole
Description Implicit IAM Role created for GoUpstashRedis
Value arn:aws:iam::<redacted>:role/UpstashRedisGoArticleStac-GoUpstashRedisRole-16UWC7HR6KII8
 
Key GoUpstashRedisApi
Description Endpoint URL
Value https://6pmmwqmg5vec3bcsldabckaf5i0nlgje.lambda-url.eu-west-1.on.aws/
-----------------------------------------------------------------------------------------------------------------------------------------------------------
 
Successfully created/updated stack - UpstashRedisGoArticleStackDemo in eu-west-1

• तैनात AWS लैम्ब्डा का URL मुद्रित आउटपुट में दिखाया गया है, इस मामले में https://6pmmwqmg5vec3bcsldabckaf5i0nlgje.lambda-url.eu-west-1.on.aws/ . इसलिए, बेझिझक उन डेमो चरणों को दोहराएं जो हमने localhost का उपयोग करने से पहले अपने ब्राउज़र में किए थे अब वास्तविक डोमेन के साथ।
  • वैकल्पिक रूप से, आप क्लाउडफॉर्मेशन स्टैक UpstashRedisGoArticleStackDemo के आउटपुट में नव निर्मित फ़ंक्शन का यूआरएल भी पा सकते हैं। क्लाउडफॉर्मेशन कंसोल में।
  • नोट: UPSTASH_REDIS_URL सेट करना सुनिश्चित करें आपके AWS लैम्ब्डा कॉन्फ़िगरेशन पर भी पर्यावरण चर, अन्यथा यह क्रैश हो जाएगा। AWS लैम्ब्डा कंसोल पर जाएँ, फिर अपने नए तैनात लैम्ब्डा पर क्लिक करें, कॉन्फ़िगरेशन पर क्लिक करें टैब, और फिर बाईं ओर के मेनू पर पर्यावरण चर पर क्लिक करें . UPSTASH_REDIS_URL टाइप करें कुंजी के रूप में, और आपका अपस्टैश रेडिस यूआरएल मान के रूप में। सहेजें पर क्लिक करें , और अब आपका लैम्ब्डा तैयार है।

4.1 एसएएम स्थानीय परीक्षण

• फिर, एक बार जब आपके पास एक वैध JSON इवेंट फ़ाइल हो, तो सर्वर लॉजिक को लागू करने के लिए निम्नलिखित को चलाएँ क्योंकि यह AWS लैम्ब्डा पर चलेगा:

sam local invoke -t aws-iac/sam-template.yml -e sample-event.json

4.2 अपस्टैश रेडिस यूआरएल की सुरक्षा

5. यह कितना तेज़ है?

निष्कर्ष