שרתלסס שימש כתגובה לאתגרים של מבנים השרת המסורים. בעזרת שרתלסס, מפתחים לא צריכים יותר לנהל או להגדיל שרתים באופן ידני. במקום זה, ספקי המערך מטפלים בניהול התשתית, מה שמאפשר לצוותים להתמקד בעיקר בכתיבת והעלאת הקוד.

פתרונות שרתלסס מתקנים באופן אוטומטי על ידי דרישות ומציעים מודל של שילוב שירותים. זה אומר שאתה משלם רק עבור המשאבים שהיישומך משתמש בהם באמת. הגישה זו מאוד מפחיתה את העלויות ההוצאה לשירות האופרציה, מגבירה את הגמישות ומאיצה את מחזורי הפיתוח, שהיא אפשרות מוצפנת עבור הפיתוח של היישומים המודרניים.

דרך ההסטירה של ניהול השרתים, מערכות שרתלסס מאפשרות לך להתמקד בהיסטוריה העסקית ובפונקציות היישומים. זה מוביל להעלאות העלאות וליצירת יותר חדשנות. מבנים שרתלסס גם מונעים על ידי אירועים, מה שאומר שהם יכולים להגיב באופן אוטומטי לאירועים בזמן אמת ולהגדיל למטרות הצרכן בלי התערבות ידנית.

תוכן תרשים

  1. מונחים חשובים להבנה

  2. דרישות קדם

  3. היישום שלנו

  4. מטרות התרגול

  5. איך להתחיל: שכפל ה־Git Repository

  6. שלב 1: הגדרת סביבת העבודה של ה־Serverless Framework

  7. שלב 2: הגדרת הAPI בקובץ ה־Serverless YAML

  8. שלב 3: פיתחו פעולות למעלה ולמטה לפעולות קידום ומחיקה

  9. שלב 4: הגדר צינור CI/CD עם פרסומים מרובים לסביבות הפיתוח והפקוד

  10. שלב 5: בדיקת צינורות הפיתוח והפקוד

  11. שלב 6: בדיקה ואימות של API-ים בסביבת הפקוד והפיתוח באמצעות Postman

  12. מסקנה

לפני שנכנס לפרטים הטכניים, נבין כמה מושגים מרכזיים ברקע.

מושגים חשובים להבנה

ממשק תכנות אפליקציות (API)

ממשק תכנות אפליקציות (API) מאפשר לתוכנות שונות לתקשר ולאינטראקט עם זה הדבר. הוא מגדיר את השיטות ופורמטי הנתונים שתוכנות יכולות להשתמש בהם כדי לבקש ולהחליף מידע לשילוב ולשיתוף נתונים בין מערכות מגוונות.

שיטות HTTP

שיטות HTTP או שיטות בקשה הן הרכיב קריטי בשרותי רשת וAPI. הן מצביעות על הפעולה המבוקשת לביצוע על משאב בכתובת הבקשה הנתונה.

השיטות הנפוצות ביותר ב-API של RESTful הן:

  • GET: משמש להשגת נתונים מהשרת

  • POST: שולח נתונים, שכוללים בגוף הבקשה, כדי ליצור או לעדכן משאב

  • PUT: מעדכן או מחליף משאב קיים או יוצר משאב חדש אם הוא לא קיים

  • DELETE: מוחק את הנתונים המצויינים מהשרת.

Amazon API Gateway

Amazon API Gateway היא שירות מנוהל לחלוטין שמקל על מפתחים ליצור, לפרסם, לתחזק, להשגיח ולהגן על APIים בקנה מידה. הוא פועל כנקודת הכניסה למספר APIים, נוהל ושולט באינטראקציות בין לקוחות (כמו יישומים רשת או ניידים) ושרותים תוכנה אחורית.

הוא מציע גם מספר פונקציות, כוללת ניתוב בקשות, בטיחות, הזדהות, קצינה והגבלת קצב שעוזרות לפשט את ניהול והפלטת APIים.

Amazon DynamoDB

DynamoDB היא שירות מנוהל לא-SQL שמתוכנן לרמת שיפור גבוהה, בידעי מידה נמוכה ושיכפול נתונים בריבוי אזורים.

DynamoDB שומרת נתונים בפורמט ללא תבנית, מאפשר גמישות והיצורה מהירה של נתונים מבניים וחצי מבניים. היא בדרך כלל משמשת לבניית יישומים שיפורתיים ומגיבים בסביבות שמאפשרות שירותים בענן.

יישום ללא שרת CRUD

יישום ללא שרת CRUD מתייחס ליכולת ליצור, לקרוא, לעדכן ולמחוק נתונים. אך הארכיטקטורה והרכיבים העוסקים שונים מאשר ביישומים שמבוססים על שרתים מסורתיים.

יצירה כוללת הוספת רשומות חדשות לטבלת DynamoDB. הפעולה קריאה משיגה נתונים מטבלת DynamoDB. עדכון מעדכן נתונים קיימים ב-DynamoDB. והפעולה מחיקה מוחקת נתונים מ-DynamoDB.

המסגרת ללא שרת

Framework Serverless הוא כלי קוד פתוח שמפשט את הפריסה והניהול של יישומים ללא שרתים בעננים שונים, כולל AWS. הוא מפשט את המורכבות של הקצאת וניהול תשתיות על ידי כך שהוא מאפשר למפתחים להגדיר את התשתיות שלהם כקוד באמצעות קובץ YAML.

המסגרת מטפלת בפריסה, הגדלה ועדכון של פונקציות ללא שרת, APIs ומשאבים אחרים.

GitHub Actions

GitHub Actions הוא כלי CI/CD עוצמתי שמאפשר למפתחים לאוטומט את תהליכי העבודה של התוכנה ישירות ממאגר ה-GitHub שלהם.

עם GitHub Actions, אפשר ליצור צינורות מותאמים אישית שמופעלים על ידי אירועים כמו דחיפות קוד, בקשות משיכה או מיזוגי ענפים. תהליכי עבודה אלה מוגדרים בקבצי YAML בתוך המאגר ויכולים לבצע משימות כמו בדיקה, בנייה ופריסה של יישומים לסביבות שונות.

Postman

Postman הוא פלטפורמת שיתוף פעולה פופולרית שמפשטת את התהליך של עיצוב, בדיקה ותיעוד APIs. היא מציעה ממשק ידידותי למשתמש למפתחים ליצור ולשלוח בקשות HTTP, לבדוק נקודות קצה של API ולהאוטומט תהליכי בדיקה.

טוב, עכשיו כשאתם מכירים את הכלים והטכנולוגיות שנשתמש בהם כאן, בואו נצלול פנימה.

דרישות קדם

  • Node.js ו-npm מותקנים

  • CLI של AWS מוגדר עם גישה לחשבון ה-AWS שלכם

  • חשבון Framework Serverless

  • פריימוורק ללא שרת מותקן באופן גלובלי ב-CLI המקומי שלך

המקרה שלנו

פגוש את אליקס, יזם שלאחרונה למד על ארכיטקטורת שרתים ללא שרת. היא קראה על איך זהו דרך עוצמתית ויעילה לבנות מערכות גב-צד ליישומי אינטרנט, המציעה גישה מודרנית יותר לפיתוח יישומים אינטרנטיים.

היא רוצה להחיל את מה שלמדה עד כה על יסודות של חישוב ללא שרתים ב-AWS. היא יודעת שללא שרתים אין משמעות שאין שרתים מעורבים – סתם זה מספק תרגום לניהול והספקת שרתים. ועכשיו היא רוצה להתמקד בכתיבת קוד והטמעת ביצועי עסקים.

בואו נראה כיצד אליקס, בעלת קיוסק קפה מצליח, מתחילה לנצל את ארכיטקטורת השרתים ללא שרתים עבור גב היישום האינטרנטי שלה.

קיוסק הקפה של אליקס, קיוסק קפה מקוון, מציע מגוון של תערובות קפה וטיפוחים למכירה. בתחילה, אליקס ניהלה את הזמנות החנות והמלאי באמצעות שירותי אירוח ותפעולים אינטרנטיים מסורתיים, שבהם טיפלה במספר שרתים ומשאבים. אך כפי שהקיוסק הקפה שלה גדל בפופולריות, היא התמודדה עם מספר הזמנות מוגבר, במיוחד בשעות השיא ובעת קידומים עונתיים.

ניהול השרתים והבטיחות שהיישום יכול להתמודד עם עליית התנועה הפך לאתגר עבור אליקס. היא מצאה את עצמה מתדאגת תמיד לנפח השרתים, לגמישות ולעלות התחזוקה של התשתית.

היא גם רצתה להציג תכונות חדשות כמו מומחים אישיים ותוכניות LOYALTY, אך זה הפך למשימה מאתגרת בהתחשב במגבלות של התקנה המסורתית שלה.

אז אליק למדה על הרעיון של מחשבה חסרת שרת. היא השווה מחשבה חסרת שרת לבריסטאה שמכינה קפה בזמן אמת באופן אוטומטי, בלי שום דאגה על פרטים המפורטים בתהליך הקפה.

היא התרגשה מהרעיון הזה והחליטה להעביר את האחסון של הקפה שלה לפלטפורמה חסרת שרת בעזרת AWS Lambda, AWS API Gateway ו-Amazon DynamoDB. התקנה זו תאפשר לה להתמקד יותר על הכיתוף של הקלאסים המושלמים והמתנדבים עבור הלקוחות שלה.

עם המחשבה החסרת השרת, כל הזמנה של הלקוח הפכה לאירוע שמושלם סדרה של פונקציות חסרות השרת. פונקציות נפרדות AWS Lambda מעבדות את ההזמנות ומטפלות בהגיון העסקי מאחורי הרציף. לדוגמא, הן יוצרות הזמנה של הלקוח ומסוגלות להביא אותה. הן יכולות גם למחוק את ההזמנה של מישהו או לעדכן את מצב ההזמנה.

אליק לא צריכה לדאוג על ניהול השרתים, כי הפלטפורמה החסרת השרתים מריצה באופן אוטומטי את הגודל בהתאם לבקשות ההזמנות המגיעות. גם היעילות הכלכלית של המחשבה החסרת השרתים היא עצומה עבור אליק. עם מודל של שילוב של מה שהיא צריכה, היא משלמת רק עבור הזמן המ

אבל היא לא מפסיקה שם! היא גם רוצה לאוטומטизם הכל, מהפצת תשתית ועד לעדכון היישום שלה כל פעם שיש שינוי חדש. על-ידי שימוש ב-Infrastructure as Code (IaC) עם הספרטלס פריימוורק, היא יכולה להגדיר את כל התשתית שלה בקוד ולנהל אותה בקלות.

בנוסף, היא מתקינה אפקטים של GitHub לשירותים מתמשכים ומספקים (CI/CD), כך שכל שינוי שהיא עושה יופץ באופן אוטומטי דרך תהליך, בין אם זה תכונה חדשה בפיתוח או תיקון מיידי לייצור.

מטרות ההדרכה

  • הקמת סביבת ספרטלס פריימוורק

  • הגדרת API בקובץ YAML

  • פיתוח פונקציות AWS Lambda לעיבוד פעולות CRUD

  • הקמת הפצות רב-שלביות למצבי פיתוח וייצור

  • בדיקת תהליכי הפיתוח והייצור

  • בדיקה ואימות של API מצבי פיתוח וייצור באמצעות Postman

איך להתחיל: עתידת מקום גיט

בכן, תעבירו לכאן . כשאנחנו מתקדמים, ניתן בפנוה לערוך את הקבצים כפי שתרצו.

לאחר שתעשו שיבוט של המאגר, תשימו לב להודעה על קיומם של מספר קבצים בתיקייה שלכם, כפי שניתן לראות בתמונה שלהלן. נשתמש בכל הקבצים הללו כדי לבנות את הAPI של המקהלת הללוית שרותים.

שלב 1: הקמת סביבת סרברלס פריימוורק

כדי להקים את סביבת סרברלס פריימוורק להעברות אוטומטיות, תצטרכו לאשר את חשבון הסרברלס דרך המסך המפקד.

זה דורש ייצור מפתח גישה שמאפשר לצינורת הCI/CD ומשתמש בסרברלס פריימוורק כדי להיאשר באופן בטוח לחשבון שלכם בלי לחשוף את האישורים שלכם. על-ידי התחברות לחשבון הסרברלס שלכם ויצירת מפתח גישה, הצינורת יכולה להעביר את היישום הללוי שלכם באופן אוטומטי מקובץ ההגדרות הבנייה.

כדי לעשות זאת, תעברו לחשבון הסרברלס שלכם ותנווטו לחלק המפתחות גישה. תלחצו על "+add", תכניסו לו שם SERVERLESS_ACCESS_KEY ואז תיצורו את המפתח.

לאחר שיצרתם את מפתח הגישה, תשמרו בבטחה להעתיקו ולאחסן אותו. תשתמשו במפתח זה כמשתנה סודי במאגר הגיטהאב שלכם כדי לאשר ולהעניק הרשאות לצינורת הCI/CD.

המשתמש יקבל גישה לחשבון Serverless Framework בתהליך ההגדרה. אתה תוסף את המפתח הזה לסודות המאגר של הגיתאבוק שלך בהמשך, כך שהערך יכול באופן בטוח להשתמש בו בתהליך ההגדרה של המשאבים הלא שרתיים בלי להציג מידע רגיש במקור הקוד.

עכשיו, בואו נגדל את המשאבים בתוך הקוד בעזרת הקומונס הזה בשורה severless.yaml.

שלב 2: הגדרת הAPI בקומונס הסרבלססס הזה

בקומונס הזה, תוכל להגדיר את התשתית הבסיסית והפונקציות של ה API של הקפה הקטן בעזרת ההגדרות הYAML של המערכת הסרבלססס.

קומונס זה מגדיר את השירותים האמריקניים המשמשים, כולל גלילת הממשק, פונקציות לambda למשימות CRUD ודינמודבי בשביל אחסון המידע.

הם גם יתארו תפקיד IAM כך שלפונקציות הלambda יהיו הרשאות הנחוצות לתקשורת עם שירות הדינמודבי.

הגלילת הממשק מוגדרת עם שיטות HTTP מתאימות (POST, GET, PUT, ו DELETE) כדי לטפל בבקשות הנכנסות ולהפעיל את הפונקציות התואמות.

בואו נבדוק את הקוד:

service: coffee-shop-api
frameworkVersion: '4'

provider:
  name: aws
  runtime: nodejs20.x
  region: us-east-1
  stage: ${opt:stage}
  iam:
    role:
      statements:
        - Effect: Allow
          Action:
            - dynamodb:PutItem
            - dynamodb:GetItem
            - dynamodb:Scan
            - dynamodb:UpdateItem
            - dynamodb:DeleteItem
          Resource: arn:aws:dynamodb:${self:provider.region}:*:table/CoffeeOrders-${self:provider.stage}

functions:
  createCoffee:
    handler: createCoffee.handler
    environment:
      COFFEE_ORDERS_TABLE: CoffeeOrders-${self:provider.stage}
    events:
      - http:
          path: coffee
          method: post

  getCoffee:
    handler: getCoffee.handler
    environment:
      COFFEE_ORDERS_TABLE: CoffeeOrders-${self:provider.stage}
    events:
      - http:
          path: coffee
          method: get

  updateCoffee:
    handler: updateCoffee.handler
    environment:
      COFFEE_ORDERS_TABLE: CoffeeOrders-${self:provider.stage}
    events:
      - http:  
          path: coffee  
          method: put  

  deleteCoffee:  
    handler: deleteCoffee.handler
    environment:
      COFFEE_ORDERS_TABLE: CoffeeOrders-${self:provider.stage}
    events:
      - http:
          path: coffee
          method: delete
resources:
  Resources:
    CoffeeTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: CoffeeOrders-${self:provider.stage}
        AttributeDefinitions:
          - AttributeName: OrderId
            AttributeType: S
          - AttributeName: CustomerName
            AttributeType: S
        KeySchema:
          - AttributeName: OrderId
            KeyType: HASH
          - AttributeName: CustomerName
            KeyType: RANGE
        BillingMode: PAY_PER_REQUEST

קומונס הserverless.yml מגדיר איך ה API של Alyx של הקפה הקטן יפעל בסביבה ללא שרת על ה AWS. החלק provider מציין שהיישום יהשתמש ב AWS כספק הענן, עם Node.js</diy17

כאן האזור מוגדר ל us-east-1 והמשתנה stage מאפשר העלאה דינמית של פיתוח לסביבות שונות, כמו dev וprod. זה אומר שאותו קוד יכול להיות מוטמע בסביבות שונות, עם המשאבים מתויגים בהתאם למניעת סתירות.

בחלק iam מוענקים הרשאות לפונקציות Lambda לתקשר עם טבלת DynamoDB. הסינטקס ${self:provider.stage} שמשם אותו שם דינמית לטבלת DynamoDB, כך שלכל סביבה יש משאבים נפרדים, כמו CoffeeOrders-dev עבור הסביבה הפיתוחית וCoffeeOrders-prod עבור הפקה. שימוש בשינוי השם הדינמי עוזר בניהול סביבות מרובות בלי להגדיר טבלאות נפרדות באופן ידני לכל אחת מהן.

חלק functions מגדיר את ארבעת הפונקציות הליבה של Lambda, createCoffee, getCoffee, updateCoffee וdeleteCoffee. הן מתפקדות עם הפעולות CRUD עבור API של הקפה.

לכל פונקציה מקושרת מתוכנה מסויימת של שיטת HTTP בשרת הAPI, כמו POST, GET, PUT וDELETE. הפונקציות האלו יוצרות קשר עם הטבלה של DynamoDB שמונהימת על פי השלב הנוכחי.

חלק resources האחרון מגדיר את טבלת DynamoDB עצמה. הוא מגדיר את הטבלה עם המאפיינים OrderId וCustomerName, שמשמשים כמפתח ראשי. הטבלה מוגדרת להשתמש במידה של תשלום לפי השיגור, כך שהיא יעילה כלכלית עבור העסק של Alyx

דרך אוטומציות ההגדרה של המשאבים האלה בעזרת המערכת השרתליס שלי, אליקס יכולה לנהל בקלות את התשתית שלה, ולהשחרר את עצמה מהמשקל של העיצוב וההגדלה מודרנית של המשאבים.

שלב 3: פיתוח הפונקציות לעיתים של CRUD

בשלב זה, אנחנו מבצעים את הלוגיקה היסודית של ה API של הקפה של אליקס על ידי יצירת פונקציות לambda עם ג 'שפת ג' בוסקס שמבצעות את הפעילויות CRUD העיקריות createCoffee, getCoffee, updateCoffee ו deleteCoffee.

הפונקציות אלה משתמשות ב SDK AWS כדי לתקשר עם שירותי AWS, בעיקר דינמודב. לכל פונקציה יהיה אחת מחוברת לטפלים API ספציפיים כמו יצירת הזמנה, הבאת ההזמנות, עדכון מצבים ההזמנות, ומחיקת ההזמנות.

פונקציית יצירת קפה

הפונקציה הזו יוצרת הזמנה:

const AWS = require('aws-sdk');
const dynamoDb = new AWS.DynamoDB.DocumentClient();
const { v4: uuidv4 } = require('uuid');

module.exports.handler = async (event) => {
  const requestBody = JSON.parse(event.body);
  const customerName = requestBody.customer_name;
  const coffeeBlend = requestBody.coffee_blend;
  const orderId = uuidv4();

  const params = {
    TableName: process.env.COFFEE_ORDERS_TABLE,
    Item: {
      OrderId: orderId,
      CustomerName: customerName,
      CoffeeBlend: coffeeBlend,
      OrderStatus: 'Pending'
    }
  };

  try {
    await dynamoDb.put(params).promise();
    return {
      statusCode: 200,
      body: JSON.stringify({ message: 'Order created successfully!', OrderId: orderId })
    };
  } catch (error) {
    return {
      statusCode: 500,
      body: JSON.stringify({ error: `Could not create order: ${error.message}` })
    };
  }
};

הפונקציה הזו מטפלת ביצירת הזמנה חדשה בטבלת דינמודב שלה. בהתחלה אנחנו מיישמים את ה AWS SDK ומיישמים את DynamoDB.DocumentClient כדי לתקשר עם דינמודב. גם הספרה uuid מוילדת בעזרתה מספרים מייצגים ספציפיים.

בתוך הפונקציה handler, אנחנו פרשים את הבקשה המגיעה כדי לקחת את המידע הלוקאלי ולהעביר את המידע הנחוץ להכנסה לדינמודב.

הערך params מגדיר את הטבלה בה הנתונים יישמרו, עם TableName שמוגדר באופן דינמי לערך של המשתנה הסביבתית COFFEE_ORDERS_TABLE. ההזמנה החדשה כוללת שדות כמו OrderId, CustomerName, CoffeeBlend, ומצב ההתחלה Pending אחד.

באים try בלוק, הקוד מנסה להוסיף את ההזמנה לטבלה DynamoDB בעזרת שיטת put(). אם זה מצליח, הפונקציה מחזירה קוד סטטוס 200 עם מסר הצלחה וOrderId. אם קורה שגיאה, הקוד מתפיס אותה ומחזיר קוד סטטוס 500 ביחד עם מסר שגיאה.

פונקציית קבלת קפה

הפונקצייה הזו משחזרת כל החלקים הקפה:

const AWS = require('aws-sdk');
const dynamoDb = new AWS.DynamoDB.DocumentClient();

module.exports.handler = async () => {
  const params = {
    TableName: process.env.COFFEE_ORDERS_TABLE
  };

  try {
    const result = await dynamoDb.scan(params).promise();
    return {
      statusCode: 200,
      body: JSON.stringify(result.Items)
    };
  } catch (error) {
    return {
      statusCode: 500,
      body: JSON.stringify({ error: `Could not retrieve orders: ${error.message}` })
    };
  }
};

הפונקצייה הזו אחראית להוסיף את כל ההזמנות הקפה מטבלת DynamoDB ומדגימה גישה חסרת שרת להוסיף נתונים מטבלת DynamoDB בדרך סקאלבלית.

אנחנו משתמשים שוב ב SDK AWS כדי להתחיל את האינסטנציה DynamoDB.DocumentClient בכדי לתקשר עם DynamoDB. הפונקצייה handler בונה את הערך params, מציע את TableName, שמוגדר באופן דינמי בעזרת המשתנה הסביבתית COFFEE_ORDERS_TABLE.

scan() השיטה משלוחה את כל הרשימה מהטאבלה. שוב, אם הפעולה מצליחה, הפונקצייה יחזירה קוד מצב 200 ביחד עם הרשימה הנשארת בתוצרת JSON. במקרה של שגיאה, יש קוד מצב 500 ומסר שגיאה.

פונקציית קפה Lambda

הפונקצייה הזו מעדכנה מוצר קפה על פי מספר הזיהוי שלו:

const AWS = require('aws-sdk');
const dynamoDb = new AWS.DynamoDB.DocumentClient();

module.exports.handler = async (event) => {
  const requestBody = JSON.parse(event.body);
  const { order_id, new_status, customer_name } = requestBody;

  const params = {
    TableName: process.env.COFFEE_ORDERS_TABLE,
    Key: {
      OrderId: order_id,
      CustomerName: customer_name
    },
    UpdateExpression: 'SET OrderStatus = :status',
    ExpressionAttributeValues: {
      ':status': new_status
    }
  };

  try {
    await dynamoDb.update(params).promise();
    return {
      statusCode: 200,
      body: JSON.stringify({ message: 'Order status updated successfully!', OrderId: order_id })
    };
  } catch (error) {
    return {
      statusCode: 500,
      body: JSON.stringify({ error: `Could not update order: ${error.message}` })
    };
  }
};

הפונקצייה הזו מטפלת בעידכון המצב של ההזמנה הספציפית לקפה בטאבלת DynamoDB.

הפונקצייה handler מוציאה את order_id, new_status, וcustomer_name מתוך הגוף הבקשה. אחר כך, היא בונה את האובייקט params כדי ל指定 שם הטאבלה והמפרמט העיקרי להזמנה (בעזרת OrderId וCustomerName). UpdateExpression מגדיר את המצב החדש של ההזמנה.

באים try בלוק, הקוד מנסה לעדכן את ההזמנה בטאבלת DynamoDB בעזרת השיטה update(). כמובן, אם הפעולה מצליחה, הפונקצייה יחזירה קוד מצב 200 עם מסר ההצלחה. אם שגיאה קורה, היא תופסה את השגיאה ויחזירה קוד מצב 500 עם מסר שגיאה.

פונקציית מחיקה קפה Lambda

הפונקצייה הזו ממחיקה מוצר קפה על פי מספר הזיהוי שלו:

const AWS = require('aws-sdk');
const dynamoDb = new AWS.DynamoDB.DocumentClient();

module.exports.handler = async (event) => {
  const requestBody = JSON.parse(event.body);
  const { order_id, customer_name } = requestBody;

  const params = {
    TableName: process.env.COFFEE_ORDERS_TABLE,
    Key: {
      OrderId: order_id,
      CustomerName: customer_name
    }
  };

  try {
    await dynamoDb.delete(params).promise();
    return {
      statusCode: 200,
      body: JSON.stringify({ message: 'Order deleted successfully!', OrderId: order_id })
    };
  } catch (error) {
    return {
      statusCode: 500,
      body: JSON.stringify({ error: `Could not delete order: ${error.message}` })
    };
  }
};

לפעולה Lambda זה נמצאת היכולת למחוק פריט קפה ספציפי מטבלת DynamoDB. בפעולה ההאנדלר, הקוד פרסה את גוף הבקשה כדי לשלוף את הorder_id ואת הcustomer_name. הערכים הללו משמשים כמפתח ראשי לזיהוי הפריט שיורד מהטבלה. אובייקט הparams מצהיר על שם הטבלה והמפתח לפריט המועמד למחיקה.

בבלוק הtry, הקוד מנסה למחוק את ההזמנה מ-DynamoDB באמצעות השיטה delete(). במידה וזה מצליח, הוא מחזיר קוד מצב 200 עם מסר הצלחה, המראה שההזמנה נמחקה. אם מתרחש טעות, הקוד תפס אותה ומחזיר קוד 500 בנוסף למסר שגיאה.

אחרי שהסברנו על פעולת Lambda כלשהי, בואו נתקין צינורת CI/CD מסובכת.

שלב 4: הקמת צינורת CI/CD עם הפליטות במצבים שונים לסביבות Dev וProd

כדי להקים סודות AWS במאגר GitHub שלך, תביטו קודם בהגדרות המאגר. בחרו בSettings בפינה הימנית העליונה, ואז הכנסו לפינה השמאלית התחתונה ובחרו בSecrets and variables.

לאחר מכן, יש ללחוץ על Actions כפי שנראה בתמונה שלהלן:

משם, בחרו בNew repository secret כדי ליצור סודות.

שלושה סודות נדרשים ליצירה עבור הצינורת שלכם, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, וSERVERLESS_ACCESS_KEY.

שימו את המפתחים לגישה בחשבון AWS בשתי המשתנות הראשונות ואז המפתח הגישה הלא-עם-שרת שהוקם בפעם הקודמת כדי ליצור את הSERVERLESS_ACCESS_KEY. הסודות הללו יאשר באופן בטוח את תהליך ה-CI/CD שלך כפי שנראה בתמונה שלהלן.

וידאו שהבסיס העיקרי שלך נקרא "main," כי זה ישמש כעץ הייצור. לאחר מכן, יצרו עץ חדש בשם "dev" לעבודה הפיתוחית.

אתם יכולים גם ליצור עצים ספציפיים לתכונות כמו "dev/feature," לפיתוח עדין יותר. פעולות GitHub ישתמשו בעצים אלו כדי להעלות שינויים באופן אוטומטי, עם dev המייצג את הסביבה הפיתוחית ו-main המייצג את הייצור.

אסטרטגיית העצים הזו מאפשרת לך לנהל את תהליך ה-CI/CD באופן יעיל, העלאות של קוד חדש כל פעם שיש מיזוג לגיטימי או הסביבה הייצורית.

איך להשתמש בפעולות GitHub להעלאת קובץ YAML

כדי לאוטומטиз את תהליך ההעלאה עבור API המקצועת הקפה, תשתמשו בפעולות GitHub שמשתלבות עם מאגר ה-GitHub שלכם.

תהליך ההעלאה הזה מופעל בכל פעם שקוד נשלח לעצים ה

או . על-ידי הגדרת העלאות סביבתיות, תוודאו שהעדכונים לעץ ה יועלו לסביבת הפיתוח, בעוד ששינויים בעץ ה
יגרמו להעלאות לייצור.

כעת, בואו נסקור את הקוד:

name: deploy-coffee-shop-api

on:
  push:
    branches:
      - main
      - dev

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v3

    - name: Setup Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '20.x'

    - name: Install dependencies
      run: |
        cd coffee-shop-api
        npm install

    - name: Install Serverless Framework
      run: npm install -g serverless

    - name: Deploy to AWS (Dev)
      if: github.ref == 'refs/heads/dev'
      run: |
        cd coffee-shop-api
        npx serverless deploy --stage dev
      env:
        AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
        AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        SERVERLESS_ACCESS_KEY: ${{secrets.SERVERLESS_ACCESS_KEY}}

    - name: Deploy to AWS (Prod)
      if: github.ref == 'refs/heads/main'
      run: |
        cd coffee-shop-api
        npx serverless deploy --stage prod
      env:
        AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
        AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        SERVERLESS_ACCESS_KEY: ${{secrets.SERVERLESS_ACCESS_KEY}}

שיטת הפעולות של GitHub Actions בסיווג YAML מאוטומטת את תהליך ההפצה של API הקפה ל-AWS באמצעות ספריית הפריים Serverless. התהליך מופעל כל פעם ששינויים נדחפים לסנפירים המרכזיים או dev.

הוא מתחיל בבדיקת קבצי הרפוסטורי, ואז מתקין Node.js בגרסה 20.x כדי להתאים את הזמן הריצה לפונקציות Lambda. לאחר מכן, הוא מתקין את התלויות הפרויקט באמצעות ניווט לתוך התיקייה coffee-shop-api וברצית npm install.

התהליך מתקין גם את ספריית הפריים Serverless באופן גלובלי, מאפשר גישה לפקודה השורת הפקודה serverless לשימוש בהפצה. תלוי בסנפיר שעודכן, התהליך מחליט באופן תנאי להפצה לסביבה המתאימה.

אם השינויים נדחפו לסנפיר dev, הוא מפצה לשלב dev. אם לסנפיר main, הוא מפצה לשלב prod. פקודות ההפצה, npx serverless deploy --stage dev או npx serverless deploy --stage prod מופעלות בתוך התיקייה של coffee-shop-api.

לשם הפצה בטוחה, התהליך משתמש באישורי AWS ומפתח הגישה לServerless באמצעות משתני סביבה שמאוחסנים בGitHub Secrets. זה מאפשר לצינורת הCI/CD להתאימה עם AWS וספריית הפריים Serverless ללא חשיפת מידע רגיש ברפוסטורי.

עכשיו, אנחנו יכולים להמשיך לבדוק את הצינורת.

שלב 5: בדוק את צינורות ההפצה של Dev וProd.

קודם כל, תצטרך לוודא שהענף העיקרי (prod) נקרא "main". אחר-כך תיצור ענף dev בשם "dev". ברגע שתעשה שינויים תקינים בענף dev, תבצע commit כדי לגרום לתהליך של GitHub Actions. זה יבצע באופן אוטומטי העברת המשאבים המעודכנים לסביבת הפיתוח. לאחר בדיקת הכל ב-dev, תוכל למזג את הענף dev לתוך הענף העיקרי.

מיזוג שינויים בענף העיקרי גם מגרם באופן אוטומטי להפעלת תהליך ההעברה לסביבת הייצור. בדרך הזו, כל העדכונים הנחוצים מושמרים ומשאבים ייצור מופצעים באופן שקט.

תוכל לעקוב אחר תהליך ההעברה ולסקור יומני פעולה מפורטים של כל ריצה של GitHub Actions על-ידי ניווט לטבלת Actions בגיטהאב שלך.

היומנים מספקים בראיות לכל שלב בפילאין, עזרה לך לוודא שכל הדברים פועלים כפי שציפיתם.

תוכל לבחור בריצה כלשהי על מנת לסקור יומנים מפורטים עבור העברות של סביבת הפיתוח והייצור, כך שתוכל לעקוב אחר ההתקדמות ולוודא שהכל פועל ברציפות.

תנווט לריצה המסוימת בGitHub Actions, כפי שמוצג בתמונה התחתונה. שם, תוכל להסתכל על פרטי ההרצה והתוצאות עבור הפילאים של הפיתוח או הייצור.

דאגו לבדוק ולהאשר גם את הפיתוח וגם את הייצור של ה-API באמצעות Postman.

שלב 6: תבדוק ותאשר את ה-API של ה-Prod וה-Dev באמצעות Postman.

עכשיו שה-APIs והמשאבים נשתמשים והם מוגדרים, אנחנו צריכים למצוא את הנקודות הקיצוניות של ה-API (הכתובות URL) שמיוצרות על ידי AWS כדי להתחיל בבקשות בכדי לבדוק את הפונקציות.

הכתובות האלה יכולות לבדוק את הפונקציות של ה-API על ידי הדבקתן פשוטה לדפדפן האינטרנט. כתובות ה-API נמצאות בתוצאות היוצא של הבניין של ה-CI/CD שלך.

כדי להשיג אותן, עבור מסלול בהתאמת GitHub Actions, תנוע לתוך המחשבות של GitHub, תבחר בבניין המצלמה האחרון המצלמה בהצלחה, ותלחץ הגשה כדי לבדוק את פרטי ההגשה עבור הנקודות הקיצוניות של ה-API המיוצרות.

תלחץ על הגשה ל-AWS בסביבה הנבחרת (Prod או Dev) במחשבות GitHub Actions. עכשיו, תמצא את כתובת ה-API המיוצרת.

עשה עתידה ושמה את הכתובת הזו, כי היא תצטרך בזמן בדיקת פונקציות ה-API שלך. הכתובת הזו היא השער שלך לוודאה שה-API המשותף פועל כפי שצפוי.

עכשיו, תעתיק אחת מכתובות ה-API המיוצרות ותהייה אותה לדף הדפדפן שלך. תראו רשימה ריקה או רשימה שמוצגת בתגובה. זה למעשה מאשר שה-API פועלת בצורה נכונה ושאתה מצליח לשלוף נתונים מטבעת DynamoDB.

אפילו אם הרשימה ריקה, היא מרמזת שה-API יכולה להתחבר לבסיס נתונים ולשחזר מידע.

לבדיקה מקיפה יותר, נשתמש ב-Postman כדי לבדוק את כל שיטות ה-API, יצירה, קריאה, עדכון ומחיקה, ונבצע את הבדיקות הללו גם בסביבת הפיתוח וגם בסביבת הייצור.

כדי לבדוק את שיטת הGET, יש להשתמש ב-Postman כדי לשלוח בקשת GET לנקודת הסיום של ה-API באמצעות הכתובת. תקבל את אותה תגובה, רשימה ריקה של הזמנות קפה כמו שנראה בתחתית התמונה שלהלן. זה מאשר את היכולת של ה-API להשיג נתונים בהצלחה, כפי שמופיע בתמונה שלהלן.

כדי ליצור באמת הזמנה, בואו נבדוק את שיטת הPOST. יש להשתמש ב-Postman שוב כדי לשלוח בקשת POST לנקודת הסיום של ה-API, עם שם הלקוח והשילוב הקפה בגוף הבקשה, כפי שמופיעים להלן :

{
  "customer_name": "REXTECH",
  "coffee_blend": "Black"
}

התגובה תהיה מסר על הצלחת ההזמנה עם מספר זיהוי ייחודי של ההזמנה.

ניתן לוודא שההזמנה החדשה נשמרה בטבלת DynamoDB על ידי בדיקת הפריטים בטבלה המסויימת לסביבה :

כדי לבדוק את שיטת הPUT, יש לשלוח בקשת PUT לנקודת הסיום של ה-API עם מספר ההזמנה הקודם וסטטוס ההזמנה חדש בגוף הבקשה כפי שמופיעים להלן :

{                                                 
  "order_id": "42a81c27-1421-4025-9bef-72b14e723c34",
  "new_status": "Ready",                                             
  "customer_name": "REXTECH"                                             
}

התגובה תהיה מסר על העדכון ההצליח של ההזמנה עם מספר ההזמנה שנוצרה.

ניתן גם לוודא שסטטוס ההזמנה עודכן מהפריט בטבלת DynamoDB.

כדי

{                                                 
  "order_id": "42a81c27-1421-4025-9bef-72b14e723c34",
  "customer_name": "REXTECH"
}

ההזמנה נמחקה בהצלחה. המספר של ההזמנה הוא:

שוב, ניתן לבדוק שההזמנה נמחקה מהטבלה DynamoDB.

סיכום

זה הכל – מזל טוב! בוצעת בהצלחה את כל הצעדים. בנינו את הAPI הסרבלוסי הזה שתומך בפעולות CRUD (Create, Read, Update, Delete) בעזרת API Gateway, Lambda, DynamoDB, Serverless Framework וNode.js, ומורד הגישה לקוד מאשר בעזרת Github Actions.

אם הגעתם לכאן, תודה רבה על הקריאה! הייתי מקווה שהיה לך ערך.

Ifeanyi Otuonye הוא מהנדס מחשב סולרי מומן בDevOps, כתיבת טכנית ויומניות הוראה כמורה טכנית. הוא מונע על ידי העדפתו ללמוד ולהתפתח והוא שוגשג בסביבות שיתוף פעולה. לפני שינויו למגזר הענן, בילה שש שנים כאתלטית מסחרית.

בתחילת 2022, הוא התחיל באינטליגנציה סטרטגית להיות מהנדס מחשב סולרי/DevOps באמצעות המלאכה עצמית והצטרפות לתוכנית מהירה של 6 חודשים למגזר הענן.

במאי 2023, הוא הגיע למטרה הזו ומקבל את תפקיד המהנדס הראשון במגזר הענן וכעת הוא הגדיר מטרה אישית נוספת לעצמה בכדי לעצמה את האנשים האחרים במסלול שלהם אל הענן.