מה זה Docker ולמה זה חשוב עבור פשטות מהירה?

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

הרעיון המרכזי מאחורי דוקר הוא הרעיון של AFLT:0 המכילה את ה- 1, יחידה סטנדרטית של תוכנה הכוללת את כל הדרוש כדי להפעיל יישום.בניגוד למכונות וירטואליות מסורתיות (VMs), מיכלים חולקים את מערכת ההפעלה המארחת הקרנל, מה שהופך אותם הרבה יותר יעיל משאבים ומהיר יותר כדי להתחיל.יעילות זו מתורגמת ישירות ללחמים מהירים יותר במהלך התפתחות ושגשוג.

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

ל[[המאה ה-20]], [[1924]]]]]], [[1924]]]]

היתרונות העיקריים של Docker עבור Prototyping ופיתוח

מהירות: איכות הסביבה מיידית

התקנות המסורתיות דורשות לעתים קרובות התקנת ידני של מסדי נתונים, זמני שפה, תורי הודעה ושירותים אחרים.תהליך זה יכול לקחת שעות ולעתים קרובות משתנה בין מערכות הפעלה.עם דוקר, אתה מגדיר את הסביבה ב-FLT:0 או קובץ FLT:1, ו Docker בונה ומתחיל את הערימה כולה בתוך שניות.

יציבות סביבות

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

⁇ ללא חתימה

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

יכולת והתאמה

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

ניהול תלות פשטות

במקום לשמור תיעוד ארוך על איך להתקין ולהגדיר תלויות, אתה מקודש הכל לתוך Dockerfile. כלים כמו Docker Compose מאפשר לך להגדיר יישומי Multi-Service (למשל, שרת אינטרנט, מסד נתונים, מטמון) בקובץ אחד.זה מקטין את זמן ההצפה עבור חברים חדשים צוות והופך אבטיפוס עצמי.

להתחיל עם Docker עבור מהיר Prototyping

התקן Docker

בקר בדף ההתקנה הרשמי של FLT:0 [Docker Install pageFLT:1] והורדת הגרסה המתאימה למערכת ההפעלה שלך.Docker Desktop זמין עבור macOS, Windows ולינוקס.

צור קשר

דוקרפטן הוא קובץ טקסט המכיל הוראות לבניית תמונה דוקר.זה מתחיל עם תמונה בסיסית (למשל, FLT:4) ולאחר מכן מוסיף את קוד היישום שלך, להתקין תלות, ומפרט את הפקודה להפעיל את היישום.

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "app.py"]

עיין בקובץ זה בשורש של מנהל הפרויקט שלך לצד ה-FLT:6 ו-FLT 7 קבצים.

לבנות את התמונה

להפעיל את הפקודה הבאה מהבמאי המכיל את הדוקרפטה:

docker build -t my-flask-app .

הדגלים של ה-FLT:9 מתייגים על התמונה עם שם (ראה LT:10) ואת הדוט אומר Docker להשתמש בדירקטוריון הנוכחי כהקשר הבנייה.Docker יבצע כל קו של Dockerfile ויפיק תמונה לא מובנת.

לרוץ את ה- Container

docker run -d -p 5000:5000 my-flask-app

הדגל פועל על ידי הדגל במצב מנותק (ברקע), ו-FLT:13 מפות נמל 5000 על המארח שלך כדי פורט 5000 במיכל.

דוגמה: Prototyping a Web Application with Flask and Docker

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

פרויקט מבנה

flask-prototype/
├── app.py
├── requirements.txt
└── Dockerfile

1.תכתבו את הבקשה

(ב) ,0) ,3

from flask import Flask, jsonify
import sqlite3

app = Flask(__name__)

def init_db():
 conn = sqlite3.connect('data.db')
 c = conn.cursor()
 c.execute('''CREATE TABLE IF NOT EXISTS items (id INTEGER PRIMARY KEY, name TEXT)''')
 c.execute("INSERT OR IGNORE INTO items VALUES (1, 'Prototype item')")
 conn.commit()
 conn.close()

@app.route('/')
def home():
 return jsonify({'message': 'Docker prototyping is fast!'})

@app.route('/items')
def get_items():
 conn = sqlite3.connect('data.db')
 c = conn.cursor()
 c.execute('SELECT * FROM items')
 items = [{'id': row[0], 'name': row[1]} for row in c.fetchall()]
 conn.close()
 return jsonify(items)

if __name__ == '__main__':
 init_db()
 app.run(host='0.0.0.0', port=5000)

(ב) ⁇ ⁇ ⁇ ⁇ ⁇ 

flask

(ב) ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇ ⁇

2. בנה וברח

docker build -t flask-prototype .
docker run -d -p 5000:5000 --name proto flask-prototype

3.לבדוק את הפרוטוטיפ

פתח את הדפדפן או השתמש ב-FLT:19:

curl http://localhost:5000/
curl http://localhost:5000/items

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

4.Iterate Quickly

לעשות שינוי (FLT:21), ולאחר מכן לבנות מחדש את:

docker build -t flask-prototype .
docker stop proto
docker rm proto
docker run -d -p 5000:5000 --name proto flask-prototype

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

שימוש בDocker Compose עבור Multi-Service Prototypes

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

תגית: Flask + PostgreSQL

(ב) ,0) , ⁇ ⁇ 

version: '3.8'
services:
 web:
 build: .
 ports:
 - "5000:5000"
 environment:
 - DATABASE_URL=postgresql://user:pass@db/mydb
 depends_on:
 - db
 db:
 image: postgres:15
 environment:
 POSTGRES_USER: user
 POSTGRES_PASSWORD: pass
 POSTGRES_DB: mydb
 volumes:
 - pgdata:/var/lib/postgresql/data

volumes:
 pgdata:

עם קובץ זה בשורש הפרויקט, לרוץ 5.3:24 כדי להתחיל את שני מכולות. אפליקציית Flask יכול להתחבר ל PostgreSQL באמצעות שם המארח FLT:25 (Docker Compose באופן אוטומטי להגדיר רשת). גישה זו מאפשרת לך אבטיפוס עם תלות דמוית ייצור מבלי להתקין שום דבר מקומי.

דוקר קומוז תומך גם בתצורה מופרזת של סביבות שונות (למשל, « LT:26 לפיתוח) לקבלת פרטים נוספים, קרא את ה-FLT:0Docker Compose תיעוד ComposephFLT:1.

שיטות טובות ביותר עבור Docker ב Prototyping

השתמש ב- Small Base Images

לדוגמה, עבור משטחים מהירים וקטנים יותר של התקפה, לבחור תמונות רזה או מבוסס אלפינים.לדוגמה, (FLT:27) הוא הרבה יותר קטן מאשר התמונה המלאה של FLT:28 עם זאת, שים לב כי אלפיני משתמש ב-FLT:29 אשר יכול לגרום להתאמה עם כמה חבילות פייתון הדורשות FLT:30.

המונחים: סגסוגת Caching

דוקר מצמיד כל שכבה של תמונה. Place הוראות שמשנות באופן בלתי צפוי (כמו התקנת חבילות מערכת או העתקת חבילות FLT:31) ליד ראש הדוקרפטה, ושמים לעתים קרובות שינוי קוד (כמו מקור היישום שלך) בתחתית.

שימוש ב-Dockerignore

(ב) כתוב (ב) "לכתוב" (ב) "לכתוב" (ב"ב, ב) "ה', ב[[1924]], [[1924]], [[1924]], [[1924]]]], [[1924]]]], [[1924]]]]]], [[1924]]]]]], [[1924]]]]]]]]

תמונות משמעות

(ב) השתמשו בתגים כתובים כמו (FLT:36 או FLT:37) כדי לעקוב אחר הציטוטים (הופנה מהדף LT:38) עבור אבטיפוס כי זה יכול להיות מעורפל.

ניקוי משאבים

לעתים קרובות, נטייה מהירה משאירה מיכלים עצורים רבים, תמונות לא בשימוש, ו כרכים אנונימיים לרוץ מעת לעת:

docker system prune -a --volumes

זה משחרר את שטח הדיסק ושומר על סביבת הפיתוח שלך.

Docker vs. .Virtual Machines for Prototyping

בעוד VMs מספקים בידוד חזק, הם במשקל כבד: הם דורשים מערכת הפעלה מלאה של אורח, לצרוך ג'יגה-בתים של זיכרון, ולקחת דקות כדי להעלים. Containers, מצד שני, אתחול במלי שניות בלבד וצורכים רק את המשאבים הדרושים על ידי היישום. for Prototyping, שבו אתה יכול לסובב סביבות רבות בזמן קצר, מכולות לינוקס הם המנצח ברור איפה VM עדיין צריך להיות טיפול אבטחה שונה לחלוטין.

חדור אל תוך זרימת העבודה Prototyping שלך

בקרת גרסאות עבור תמונות

לדחוף את תמונות האבטיפוס שלך למרשם מכולות (Docker Hub, GitHub Container הרישום, או רישום פרטי) זה מקל לשתף עם משתפי פעולה ומבטיח כי אב הטיפוס שלך נגיש גם אם המכונה המקומית שלך לא מקוון.

בדיקה אוטומטית עם CI /CD

בשלב מהיר של הסתברות, ייתכן שלא יהיה לך צינורות CI מלא, אבל אתה עדיין יכול ליהנות אימות אוטומטי.לדוגמה, אתה יכול לכתוב תסריט מבחן פשוט כי רץ בתוך מיכל ובדוק את נקודות קצה HTTP. כלים כמו FLT:0Docker עם GitHub ActionsFLT:1 יכול לבנות את התמונה שלך, להפעיל, להפעיל, לדחוף אותו באופן אוטומטי על כל פעולה.

עומס חם ל- Faster Iterations

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

docker run -d -p 5000:5000 -v $(pwd):/app flask-prototype

לשלב את זה עם שרת פיתוח התומכת בעומס אוטומטי (מצב ה- debug של Flask, למשל) כדי לקבל משוב מיידי.

מלכודות נפוצות וכיצד להימנע מהם

  • (FLT:0) הגשמת נתונים באופן בלתי roperre:03F1 Containers הם אמפיריים - כאשר אתה מסיר מכולה, מערכת הקבצים שלה היא תמיד להשתמש כרכים Docker או נקשרת על גבי נתונים שיש לשרוד את המכולות מחדש.
  • (FLT:0) Exposing Unnecessary Ports:cioFLT:1) רק ממפה את הנמלים שהטיפוס שלך זקוק לו. Exposing מסדי נתונים לרשת הציבורית הוא סיכון אבטחה אפילו ב prototyping.
  • (ב) ,0) , Hard-Coding Configuration: ibph1) השתמש במשתנה הסביבה וב-FLT:41 קבצים כדי לנהל תצורה.זה שומר על הגנרית Dockerfile והופך את האבטיפוס קל לפרוס במקום אחר.
  • (ב) ,0) ,Ignoing Resource Limits: FLT:1 כברירת מחדל, מיכלים יכולים להשתמש משאבים רבים CPU וזיכרון כפי המארח מאפשר. להגדיר מגבלות באמצעות FLT:42 ו-FLT:43 כדי למנוע אבטיפוס נמלט מיישומים אחרים רעבים.

מסקנה

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

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

Embrace Docker בזרימת העבודה שלך, ואתה תמצא את עצמך שולח הוכחות של תפיסה - ובסופו של דבר לייצר יישומים - מהר יותר מאי פעם.