วิธีสร้างไปป์ไลน์การสร้างรูปภาพที่ซับซ้อนโดยใช้ Docker Buildx Bake

กราฟิกแสดงโลโก้ Docker

ขนาดนั้น docker buildx กลุ่มคำสั่งใช้ BuildKit เพื่อแสดงความสามารถในการสร้างภาพขั้นสูง บิลด์แบบอบเป็นคุณสมบัติขั้นสูงที่สามารถใช้เพื่อกำหนดไปป์ไลน์บิลด์อัตโนมัติ คุณสามารถสร้างหลายภาพในงานบิลด์เดียว

เวิร์กโฟลว์แบบอบจะมีประโยชน์เมื่อคุณต้องการเผยแพร่รูปภาพในรูปแบบต่างๆ หรือสร้างโปรเจ็กต์ที่เชื่อมโยงหลายรายการพร้อมกัน ในบทความนี้ docker buildx bake วิธีการที่สามารถใช้เพื่อทำให้งานสร้างที่ซับซ้อนง่ายขึ้น

เริ่มต้น

ขนาดนั้น docker buildx bake คำสั่งนี้เรียกใช้ “เป้าหมาย” หลายบิลด์ โดยแต่ละรายการสร้างอิมเมจคอนเทนเนอร์ เป้าหมายจะทำงานแบบคู่ขนานหากเป็นไปได้เพื่อเพิ่มประสิทธิภาพสูงสุด เป้าหมายยังสามารถอ้างอิงถึงรุ่นก่อนโดยตรงเพื่อสร้างไปป์ไลน์ตามลำดับ

เป้าหมายการสร้างสามารถกำหนดได้โดยใช้กลไกต่างๆ รวมถึงไฟล์ Docker Compose ที่มีอยู่ Buildx จะสร้างภาพทั้งหมดที่ระบุในไฟล์โดยอัตโนมัติ

การแสดงรายการเป้าหมายการสร้างในไฟล์ JSON หรือ HCL จะแสดงคุณลักษณะขั้นสูงเพิ่มเติม ตัวแปรสนับสนุน ฟังก์ชัน และการแก้ไขค่าเหล่านี้ช่วยให้คุณปรับแต่งบิลด์ของคุณได้

ขนาดนั้น buildx bake คำสั่งค้นหาไฟล์ต่อไปนี้ตามลำดับ:

  • docker-compose.yml
  • docker-compose.yaml
  • docker-bake.json
  • docker-bake.override.json
  • docker-bake.hcl
  • docker-bake.override.hcl

คุณสามารถระบุไฟล์อื่นโดยใช้: -f ธงคำสั่ง

สร้างเป้าหมาย

บิลด์เป้าหมายสรุปคอนฟิกูเรชันทั้งหมดที่เกี่ยวข้องกับบิลด์ ประกอบด้วยรายละเอียดดังต่อไปนี้:

  • พาธไปยัง Dockerfile เพื่อสร้าง
  • กำหนดเนื้อหาที่มีอยู่ภายใน Dockerfile สร้างพาธบริบท
  • แท็กและป้ายกำกับเพื่อแนบไปกับภาพที่ส่งออก
  • แพลตฟอร์มสำหรับสร้างภาพ

รายการช่องการกำหนดค่าที่รองรับทั้งหมดมีอยู่ในเอกสารประกอบ ก่อนหน้านี้คุณอาจระบุการตั้งค่าเหล่านี้เป็นแฟล็กบรรทัดคำสั่ง docker buildx build (หรือธรรมดา docker build) เพื่อจดจำค่าที่ถูกต้องทุกครั้ง กับ buildx bake คุณสามารถใช้มันได้อย่างน่าเชื่อถือโดยกำหนดค่าเดียวกันในไฟล์การควบคุมเวอร์ชันของคุณ

นี่เป็นตัวอย่างง่ายๆ docker-bake.hcl คำสั่งเพื่อกำหนดเป้าหมายการสร้างเดียว:

target "default" {
    dockerfile = "app/Dockerfile"
    contexts = {
        app = "app/src"
        shared = "shared-components/src"
    }
    tags = ["my-app:latest", "docker.io/my-org/my-app:latest"]
}

วิ่ง docker buildx bake ใช้ไฟล์อบนี้ app/Dockerfile Dockerfile ในไดเร็กทอรีการทำงานของคุณ คุณมีการเข้าถึง app/src และ shared-components/src มันใช้ไดเร็กทอรีเป็นบริบทของบิลด์ รูปภาพที่สร้างขึ้นจะได้รับแท็กสองแท็ก

ขนาดนั้น default เป้าหมายถูกสร้างขึ้นโดยอัตโนมัติเมื่อคุณเรียกใช้ docker buildx bake. คุณยังสามารถกำหนดเป้าหมายที่มีชื่อซึ่งสามารถสร้างได้ตามต้องการ

target "app" {
    // ...
}
$ docker buildx bake app

ใช้หลายเป้าหมาย

คุณสามารถสร้างรูปภาพต่างๆ ได้พร้อมกันโดยกำหนดเป็นเป้าหมายใหม่ภายในไฟล์การอบ

group "default" {
    targets = ["app", "api"]
}

target "app" {
    dockerfile = "app/Dockerfile"
    contexts = {
        app = "app/src"
        shared = "shared-components/src"
    }
    tags = ["my-app:latest", "docker.io/my-org/my-app:latest"]
}

target "api" {
    dockerfile = "api/Dockerfile"
    contexts = {
        src = "https://news.google.com/__i/rss/rd/articles/api/src"
    }
    tags = ["my-api:latest", "docker.io/my-org/my-api:latest"]
}

รูปภาพเหล่านี้ซ้อนกันเป็นกลุ่ม คุณจึงสร้างได้พร้อมกัน ขนาดนั้น api และ app รูปภาพจะถูกสร้างขึ้นพร้อมกันทุกครั้งที่คุณเรียกใช้ docker buildx bake สั่งการ default กลุ่มจะถูกเลือกโดยอัตโนมัติ คุณสามารถใช้กลุ่มที่มีชื่อคล้ายกับตัวอย่างเป้าหมายที่มีชื่อด้านบน

สร้างมรดกเป้าหมาย

บิลด์เป้าหมายสามารถสืบทอดจากกันและกันเพื่อนำการกำหนดค่ากลับมาใช้ใหม่ได้ สถานการณ์หนึ่งที่อาจเป็นประโยชน์กับรูปภาพที่ต้องปรับแต่งสำหรับสภาพแวดล้อมที่แตกต่างกัน ไฟล์คอนฟิกูเรชันเพิ่มเติมสามารถเพิ่มลงในตัวแปรรูปภาพเพื่อการพัฒนาได้ ที่นี่ docker-bake.hcl โชว์รุ่นนี้.

group "default" {
    targets = ["backend", "backend-dev"]
}

target "backend" {
    dockerfile = "backend/Dockerfile"
    contexts = {
        src = "https://news.google.com/__i/rss/rd/articles/api/src"
        config = "api/config"
    }
    tags = ["backend:latest"]
}

target "backend-dev" {
    inherits = ["backend"]
    contexts = {
        config = "api/config-dev"
    }
    tags = ["backend:dev"]
}

ขนาดนั้น backend-dev เป้าหมายสืบทอดคุณสมบัติทั้งหมด backend เป้าหมายแต่ถูกแทนที่ config ใช้บริบทและแท็กอื่นๆ

คุณสามารถดูตัวอย่างโครงสร้างไฟล์ที่ผสานได้โดยการเรียกใช้: bake สั่งการ --print ธง:

$ docker buildx bake --print
...
    "backend-dev": {
      "context": ".",
      "contexts": {
        "config": "api/config-dev",
        "src": "https://news.google.com/__i/rss/rd/articles/api/src"
      },
      "dockerfile": "backend/Dockerfile",
      "tags": [
        "backend:dev"
      ]
    }
...

ใช้เป้าหมายก่อนหน้าเป็นภาพฐาน

บางครั้งคุณอาจต้องการให้เป้าหมายการสร้างใช้รูปภาพที่สร้างโดยเป้าหมายก่อนหน้าเป็นฐานของตัวเอง นี่เป็นทางเลือกแทนบิลด์แบบหลายขั้นตอนที่สามารถใช้ได้เมื่อ Dockerfiles พึ่งพาซึ่งกันและกัน แต่ไม่สามารถรวมเข้าด้วยกันได้ อาจเป็นเพราะพวกเขามีอยู่ในโครงการต่างๆ

group "default" {
    targets = ["org-base-image", "api"]
}

target "org-base-image" {
    dockerfile = "docker-base/Dockerfile"
    tags = ["org-base-image:latest"]
}

target "api" {
    dockerfile = "api/Dockerfile"
    contexts = {
        base = "target:org-base-image"
    }
    tags = ["api:latest"]
}

ตัวอย่างก่อน org-base-image เป้า. ซึ่งอาจรวมถึงยูทิลิตีบางอย่างที่ใช้กับปริมาณงานคอนเทนเนอร์ขององค์กรของคุณ ขนาดนั้น api เป้าหมายจะถูกสร้างขึ้นด้วยผลลัพธ์ของ: org-base-image ใครสามารถเข้าถึง base สร้างบริบท API Dockerfile สามารถอ้างอิงเนื้อหาภายในอิมเมจพื้นฐานได้แล้ว

COPY --from=base /utilities/example /usr/bin/example-utility

นี่เป็นรูปแบบที่มีประสิทธิภาพที่ช่วยให้คุณสร้างลิงก์การขึ้นต่อกันระหว่างรูปภาพในขณะที่รักษา Dockerfiles แยกจากกัน

แทนที่คุณสมบัติเป้าหมาย ณ เวลาสร้าง

ขนาดนั้น docker buildx bake คำสั่งอนุญาตให้คุณแทนที่คุณสมบัติของเป้าหมายเมื่อรันบิลด์

$ docker buildx bake --set api.dockerfile="api/Dockerfile-dev"

ในตัวอย่างนี้ api เป้า. ขนาดนั้น * รองรับไวลด์การ์ดเมื่อระบุสิ่งที่ต้องเปลี่ยนแปลง * พร้อมเลือกเป้าหมายทั้งหมดด้วยตัวเอง api* แก้ไขเป้าหมายทั้งหมดที่ขึ้นต้นด้วย . api.

การตั้งค่าตัวแปร

ไฟล์ HCL สามารถกำหนดตัวแปรที่สามารถอ้างอิงได้โดยเป้าหมายการสร้าง ใช้ variable ในการตั้งค่าบล็อก ให้ทำดังนี้:

variable "TAG" {
    default = "latest"
}

group "default" {
    targets = ["app"]
}

target "app" {
    dockerfile = "src/Dockerfile"
    tags = ["my-app:${TAG}"]
}

วิ่ง docker buildx bake การใช้การกำหนดค่านี้ app เป้า my-app:latest. คุณสามารถเปลี่ยนค่าของ TAG ตัวแปรโดยการตั้งค่าตัวแปรสภาพแวดล้อมก่อนรันคำสั่ง:

$ TAG=v1 docker buildx bake

คุณสามารถใช้คุณสมบัติการแก้ไขและการเปรียบเทียบตัวแปรทั้งหมดของภาษา HCL เพื่อทำให้เป้าหมายการสร้างของคุณนำมาใช้ซ้ำได้ ฟังก์ชันยังสามารถใช้เพื่อแยกวิเคราะห์และแปลงค่า

สรุป

บิลด์ Buildx แบบอบช่วยให้คุณสามารถสรุปคอนฟิกูเรชันบิลด์อิมเมจเป็น “เป้าหมาย” ที่กำหนดไว้ในไฟล์ เมื่อคุณวิ่ง buildx bakeรูปภาพสำหรับเป้าหมายที่อ้างอิงทั้งหมดสร้างขึ้นพร้อมกัน

เป้าหมายสามารถสืบทอดและพึ่งพาซึ่งกันและกันได้ คุณยังสามารถใช้ตัวแปรและฟังก์ชันเพื่อสร้างไปป์ไลน์บิลด์ที่ซับซ้อนและกำหนดค่าได้

ขนาดนั้น docker buildx bake คำสั่งเป็นงานขั้นสูงที่ไม่จำเป็นในเวิร์กโฟลว์ใดๆ คุณไม่จำเป็นต้องใช้มันเพื่อสร้างภาพง่ายๆ ที่ไม่มีการพึ่งพาข้ามโปรเจ็กต์ ใช้ docker compose build เป็นทางเลือกที่ดีกว่าสำหรับกรณีการใช้งานส่วนใหญ่ในการรักษาการกำหนดค่าบิลด์ docker-compose.yml ไฟล์. เมื่อสร้างรูปภาพจำนวนมากพร้อมกันโดยใช้ตัวแปร แพลตฟอร์ม บริบทของบิวด์ และการแทนที่การกำหนดค่าต่างๆ คุณควรพิจารณาเปลี่ยนไปใช้บิลด์แบบอบ