ליצור Slack Bot באמצעות Hubot להפעלת פעולות GitHub באופן מושלם

אם אתה משתמש ב-GitHub Actions כתהליך בנייה ושחרור שלך וגם הקבוצה שלך משתמשת ב-Slack, האם ידעת שאין לך אפילו לצאת מ-Slack? צור Slack bot לקריאה ל- GitHub Actions workflows ישירות מ-Slack באופן אוטומטי!

במדריך זה, אתה הולך ללמוד איך להגדיר בוט צ'אט חדש ב-Slack באמצעות כלי בניית הבוטים הנקרא Hubot ולהפעיל באופן אוטומטי GitHub Actions workflow להתקנת קוד על שרת.

בואו נתחיל!

דרישות מקדימות

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

• A Slack Workspace
• A GitHub account and a GitHub personal token
• A Linux server to deploy code to – This tutorial will use Ubuntu 19.
• A local Linux machine – This tutorial will use Ubuntu so that all local commands will be Linux. If you’re running another operating system, the commands may be slightly different.
• פרטי כניסה SSH כדי להתחבר לשרת שבו תתבצע התקנת הקוד.
• A code editor of your choice that understands YAML like Visual Studio Code.

קשור:אוטומציה של פעולות Git בצד הלקוח עם Git Hooks

יצירת פרויקט וזרימת GitHub Actions

לפני שתוכל לקרוא במהיר ל- GitHub Actions workflows מתוך Slack, עליך ליצור תחילה את הזרימה העבורה.

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

נוגע ל:איך להגדיר את GitHub ב-Visual Studio Code!

1. פתח את יישום הטרמינל האהוב עליך.

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

mkdir ~/Hubot # צור תיקייה בשם Hubot
cd ~/Hubot    # שנה אל התיקייה Hubot

3. לאחר מכן, הפעל את npm init כדי ליצור קובץ package.json של Node.JS. הרצת npm init יוצרת פרויקט סטנדרטי של Node.JS הכולל את קובץ package.json שמכיל מידע שונה על הפרויקט ועל כל חבילות NPM תלויות בו.

npm init      # מאתחל קובץ package.json

4. כעת, צור תיקייה בשם workflows וקובץ deploy.yml לקובץ תהליך. קובץ התהליך הוא סדרה של שלבים שמוגדרים בסדר שGitHub Actions יעקוב אחריהם.

mkdir .github/workflows && touch deploy.yml

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

בקר בכתובת ה-URL הזו https://github.com/yourusername/yourrepository/settings/secrets/actions כאן תוסיף את סודות ה-GitHub שלך. החלף yourusername בשם המשתמש שלך ב-GitHub וyourrepository בשם המאגר שלך ב-GitHub.

לחץ על כפתור סוד חדש למאגר, כפי שמוצג למטה, כדי למלא את המידע על הסוד שאתה מוסיף.

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

ודא שאתה שומר סודות עבור המשתנים הנתונים עם אותו שם בדיוק מקביל, שהם HOST, USERNAME, PASSWORD, ו-PORT.

7. לבסוף, פתח את הקובץ ~/Hubot/.github/workflows/deploy.yml של זרימת העבודה בעורך הקוד שלך, והעתק/הדבק את הקוד הבא. הקוד למטה הוא הזרימה שתרוץ בכל פעם שתפעיל את הזרימה דרך סלאק מאוחר יותר.

כאשר אתה מפעיל את הזרימה, יתרוותנו מספר פעולות:

• GitHub Actions יפענח את קובץ העבודה למטה כדי לבצע SSH אל host המוגדר בסוד HOST עם שם משתמש וסיסמה המוגדרים כסודות בשם USERNAME ו־PASSWORD.
• העבודה תוריד אז תוכן ממאגר ה-GitHub עבור סניף מסוים ($branchName) על ידי הפעלת git pull origin$branchName. ודאו ששם הסניף מכיל את הקוד שתרצו להעלות.
• תשתמשו ב־חבילת עבודה מה-שוק GitHub בשם ssh-remote-commands. החבילה כוללת כדורגל נחמד שמאפשר לעקוף מצב שבו עליכם לספק רק את המארח, שם המשתמש, הסיסמה, הפורט, והפקודה להרצה בסביבת הייצור.

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

# שם שיוזכר יעשה הרבה יותר עם זה תכנתי
name: deploy 
on:
  # האירוע respository_dispatch אומר בכל פעם שיש trigger API,
  # הקובץ כולו מופעל
  repository_dispatch: 
    types: [deploy-service]
# יכול להיות רבים משימות, אך כרגע,
# המדריך הזה יעבוד רק על אחת
jobs:
  deploy:
    name: Deploy
    # שם התמונה הבסיסית שבה מתבצעים כל הקודים ב YAML
    runs-on: ubuntu-latest
    steps:
    - name: executing remote ssh commands using password
      # appleboy/ssh-action@master זה חבילה מקורית פתוחה
      # שנכנסת לשרת באמצעות ssh ומפעילה את הסקריפט
      uses: appleboy/ssh-action@master
      # אלה בדרך כלל המשתנים שהחבילה צריכה
      # כדי להיכנס לשרת ולהפעיל את הסקריפט
      with:
       # הסודות הם המשתנים מ
       # https://docs.github.com/en/actions/security-guides/encrypted-secrets

       # המארח של השרת המאוחסן בסודות של github עם אותו שם HOST
        host: ${{ secrets.HOST }} 
        # שם המשתמש של השרת שלך להתחברות
        # המאוחסן בסודות של github בשם USERNAME
        username: ${{ secrets.USERNAME }} 
        # הסיסמה של השרת שלך להתחברות
        # המאוחסנת בסודות של github בשם PASSWORD
        password: ${{ secrets.PASSWORD }} 
        # הפורט של השרת שלך להתחברות
        # המאוחסן בסודות של github בשם PORT
        port: ${{ secrets.PORT }}  
        # deploy-app.sh יכול להיות כל דבר כמו יכולים למשוך קוד מ GitHub
        # ולאתחל שוב את שרת האינטרנט או התורים כל דבר
        # ודא שיש לך את המאגר מועתק על השרת שלך
        # אתה יכול להריץ כמה סקריפטים שתרצה
        script: git pull origin {{ github.event.client_payload.branch 

הפעלת תהליך העבודה באופן ידני

יצרת כעת את תהליך הפעולות של GitHub Actions להפעלה דרך Slack. אך בנקודה זו, הקוד שלך נמצא רק במחשב המקומי שלך. כדי להפעיל את תהליך העבודה, יהיה עליך לדחוף קוד ל־GitHub.

הרצת סדרת הפקודות למטה מספרת ל־git איפה יש לדחוף ולמשוך את הקוד מ־GitHub המרוחק שלך. בפקודת git remote add origin למטה, החלף את yourusername וְ yourrepository בשם המשתמש שלך ב־GitHub ובשם המאגר שלך

# פתח/י את github.com וצור/י מאגר
git init # הפעלת git
git remote add origin https://github.com/yourusername/yourrepository.git
git add . # הוספת קבצים חדשים שנוצרו ל־git כדי לעקוב אחריהם
git commit -m "Created GitHub workflow file"
git push -u origin master

בואו נבדוק תחילה אם הקוד שלך עובד. הפעל/י את הקוד שלך באופן ידני באמצעות התוסף הפופולרי curl.

הפעיל/י את הפקודה למטה כדי לבצע בקשת post למאגר ה־GitHub שלך בכתובת URL https://github.com/username/repository/dispatches כדי להודיע ל־GitHub להפעיל קובץ תהליך עבודה deploy.yml שיצרת במקור. החלף/י את username בשם המשתמש האמיתי שלך ב־GitHub ואת repository במאגר ה־GitHub שלך.

החלף/י את $github_personal_token בקוד למטה באמצעות האקספרסיה האישית שלך.

# ביצוע בקשת POST בכתובת https://github.com/username/repository/dispatches 
curl-X POST  https://github.com/username/repository/dispatches \
# הוספת כותרת לקבלת סוג תוכן 
-H 'Accept: application/vnd.github.everest-preview+json' \
# הוספת כותרת לאימות 
-H "Authorization: token $github_personal_token" \
# הוספת גוף כתוב בפורמט JSON לבקשת POST כך שניתן לשלוח מספר פרמטרים רבים 
# מהמקטע זה ניתן לשלוף מספר פרמטרים ולבצע פעולות שונות בהתאם לארגומנטים 
--data '{"event_type": "deploy-service", "client_payload": {"environment": "'"$1"'", "ref": "'"$2"'"}}' # ניתן להעביר את שם הסביבה וה- ref כשם עניין והם ישמשו כשם עניין לפעולה בסוג של עניין 

יצירת Slack Bot עם Hubot

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

יש לך שני אפשרויות ליצירת Slack Bot, או לבנות אחד מאפס או להשתמש בחבילת hubot מוכנה עבור workspaces של Slack. במדריך זה, תשתמש בחבילת Bot מוכנה בשם Hubot. Hubot הוא כלי אוטומציה פתוח המשתלב עם שירותי צ'אט כמו Slack, Discord, Gitter, TeamSpeak ועוד.

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

התקנת Hubot עם Npm

מכיוון שאתה משתמש ב-Hubot ליצירת בוט של Slack, יש להוריד ולהתקין את Hubot תחילה במחשב המקומי שלך. Hubot יהיה המחבר המקשר בין Slack לפעולות GitHub.

1. בטרמינל שלך, נווט (cd) לתיקיית הפרויקט שלך (~/Hubot).

cd ~/Hubot

2. התקן את החבילות yo ו־generator-hubot באופן גלובלי (-g) במחשב המקומי שלך עם פקודת npm install. החבילה yo עוזרת לך להתקין פרויקטים חדשים על ידי יצירת פרויקטים בכל שפה (Web, Java, Python, C#, וכו'). החבילה generator-hubot משתמשת בחבילה yo להתקנת כל התלות יחד עם הגדרות ראשוניות.

לאחר ההתקנה, תוכל להריץ את הפקודה yo מכל מקום, שכן הותקן באופן גלובלי.

npm install -g yo generator-hubot

3. עכשיו, צור בסיס ל-Hubot boilerplate עם הפקודה הבאה. Boilerplate הוא קטע קוד שמתווסף בהרבה מקומות. בלעדיו, תצטרך תמיד לכתוב קוד מתוך.

הפקודה למטה יוצרת בסיס ל-Hubot boilerplate בתיקיית הפרויקט שלך. ה-Hubot boilerplate מקשר את Slack (--adapter=slack) כך שהבוט יכול להאזין ולהגיב להודעות בערוץ ה-Slack. yo hubot --adapter=slack

yo hubot --adapter=slack

הוספת Hubot למערכת ה-Slack שלך

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

בואו להתקין את Hubot במערכת ה-Slack שלך.

1. פתח את דפדפן האינטרנט שלך ונווט להגדרות המנהל של Slack עם ה-URL, כמו https://workspacename.slack.com/admin/settings. החלף workspacename בשם הממשי של מערכת ה-Slack שלך.

לחץ על Configure apps בלוח השמאלי, כפי שמוצג למטה, כדי שתוכל לחפש את Hubot בחנות. Slack יש לו חנות בה תוכל למצוא יישומים מוכנים.

2. לחץ על סרגל החיפוש, ואז הקלד hubot כדי לחפש את Hubot ב-marketplace ובחר Hubot.

כעת, לחץ על לחצן Add to Slack, כפי שאתה רואה למטה, כדי להוסיף את Hubot למערכת ה-Slack שלך.

3. לבסוף, מלא מידע כללי אודות הבוט שלך, כמו השם (deployerhubot) והאייקון. שים לב ל מזהה ה- API שכדאי לך לשמור, שתשתמש בו מאוחר יותר ב-Hubot Deployer כדי להפעיל את הבוט מתוך הפרויקט שיצרת.

בדיקת אינטגרציה של זרימת עבודה ב-GitHub Actions עם Slack

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

1. הרץ את הפקודה למטה בתוך ספריית השורש של הפרויקט כדי להפעיל את הבוט עבור Slack (--adapter slack) מתוך סוגריים זוויתיים (./bin/hubot). ודא שאתה מחליף את $token באזכור API ששמרת לך מקודם

HUBOT_SLACK_TOKEN=$token ./bin/hubot --adapter slack

2. הרץ את הפקודה למטה כדי להזמין (/invite) את הבוט (botusername) לערוץ שלך ב-Slack. החלף את botusername בשם הבוט שנרשמת בשלב השלישי של ״הוספת Hubot למקום העבודה שלך ב-Slack״.

/invite deployerhubot

עכשיו, אם תרצה לבדוק אם האינטגרציה עובדת, הזכור להזכיר לבוט בטקסט ב-Slack, לדוגמא @deployerhubot ping, ואם הבוט יגיב PONG, כפי שמוצג למטה, אז כל הכבוד.

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

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

התחלת זרימת GitHub Actions מתוך Slack

עכשיו שאתה הפעלת את הבוט שלך ב־Slack, זה הזמן להתחיל זרימת GitHub Actions מתוך Slack!

אתה צריך את הגמישות להפריד את הענף הנתון לשרת הנתון, כמו למשל למשוך את הקודים מהענף הנתון. אתה תלמד את הבוט להגיב באופן אוטומטי כאשר מישהו מקליד ***@*bot deploy API feature-x to production בערוץ ב־Slack. אתה יכול לאמת את שם הסביבה שבה בהמשך יהיה רק אנשים מסוימים שיכולים להפעיל פרקים ספציפיים וסביבות ספציפיות.

לאוטומציה של תגובות הבוט:

1. צור תיקייה בשם ~/Hubot/scripts. התיקייה ~/Hubot/scripts היא המקום שבו תשמור סקריפט שמפעיל את זרימת העבודה שלך ב־GitHub.

2. בעורך הקוד שלך, צור קובץ בשם bot.js בתוך התיקייה ~/Hubot/scripts. עכשיו העתק את הקוד למטה והדבק אותו בתוך קובץ ה־bot.js.

הקוד למטה מאפשר לבוט להקשיב להודעות הצ'אט בערוץ ב־Slack, ולאחר מכן להפעיל את זרימת העבודה ולשלוח תגובה לערוץ ב־Slack.

const validServices = ['api','app'];
const validEnvironments = ['production'];
robot.hear (`@${process.env.BOT_ID}`,async (bot) => {
    // הבוט רק מעוניין להקשיב להודעה 
    // דוגמה: @deploy api featurex to production 
    // הגדרת משתנה שימושי
	  const payload = bot.message.text.split(" ")
    const service = payload[2];
    const branch = payload[3];
    const environment = payload[5];
    const username = bot.message.user.name;
    // הודע למשתמש שאנו בתהליך עיבוד
    bot.send(`Roger that! Please wait.`);
// אימות שהפקודה שנעשתה היא תקפה או לא 
// מכיוון שהמשתמש יכול להשתמש גם בפקודות לא תקפות 
if(!validateCommand(bot,username,service,branch,environment)) {
      return;
    }
    // אם נראה שהפקודה תקפה, אז תתחיל תהליך עבודה
    await triggerWorkflow(bot,username,service,environment,branch)
    
    // הודע למשתמש כי התהליך התחיל בהצלחה
    bot.send(`Github Action has been triggered successfully`);
  })
  const validateCommand = (bot,username,service,branch,environment) => {
    // הגבל את השירותים מאחר ומשתמשים יכולים להשתמש בשירותים שאינם מופיעים ברשימה 
    // אשר ינסה להפעיל את התהליך עבודה ויקבל שגיאה
    if(!validServices.includes(service)) {
       bot.send(`${service} is not availble, Only ${validServices.join(', ')} are available`);
      return false;
      }
      // הגבל את הסביבה מאחר ומשתמשים יכולים להשתמש ברשימת סביבות שאינן תקפות גם
      if(!validEnvironments.includes(environment)) {
        bot.send(`${environment} is not availble. Only ${validEnvironments.join(', ')} are available`);
        return false;
      }
      return true;
  }

  const triggerWorkflow = (bot,username,service,environment,branch) => {
    try {
      // קוד זה הוא אותו קוד ידני להפעלת תהליך עבודה הממומש 
      // מcurl לבקשת post פועלית בג'אווהסקריפט
      const data = await axios.post(`https://api.github.com/repos/yourusername/yourreponame/dispatches`,{
        'event_type': 'deploy-service',
        'client_payload': {'environment': environment, 'ref': branch}
      },{headers:{
      Authorization: `token ${token}`,
      }})
    }
      catch(e) {
        bot.send(`Sorry @${username} could not trigger github action. Please check my logs ${e.message}`);
      }
  }

3. לבסוף, שלח את הודעת @שם_הבוט deploy api staging to dev בסלאק, ותראה תגובה דומה, כפי שמוצג למטה.

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

Conclusion

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

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