Bagikan melalui

Alur kerja pengembangan untuk aplikasi Docker

Petunjuk / Saran

Konten ini adalah kutipan dari eBook, .NET Microservices Architecture for Containerized .NET Applications, tersedia di .NET Docs atau sebagai PDF yang dapat diunduh gratis dan dapat dibaca secara offline.

Unduh PDF

Arsitektur Layanan Mikro .NET untuk thumbnail sampul eBook Aplikasi .NET Dalam Kontainer.

Siklus hidup pengembangan aplikasi dimulai pada komputer Anda, sebagai pengembang, di mana Anda membuat kode aplikasi menggunakan bahasa pilihan Anda dan mengujinya secara lokal. Dengan alur kerja ini, apa pun bahasa, kerangka kerja, dan platform yang Anda pilih, Anda tetap mengembangkan dan menguji kontainer Docker dengan melakukannya secara lokal.

Setiap kontainer (instans gambar Docker) menyertakan komponen berikut:

  • Pilihan sistem operasi, misalnya, distribusi Linux, Windows Nano Server, atau Windows Server Core.
  • File yang ditambahkan selama pengembangan, misalnya, kode sumber dan biner aplikasi.
  • Informasi konfigurasi, seperti pengaturan lingkungan dan dependensi.

Alur kerja untuk mengembangkan aplikasi berbasis kontainer Docker

Bagian ini menjelaskan alur kerja pengembangan perulangan dalam untuk aplikasi berbasis kontainer Docker. Alur kerja perulangan dalam berarti tidak mempertimbangkan alur kerja Azure DevOps yang lebih luas, yang dapat mencakup hingga penyebaran produksi, dan hanya berfokus pada pekerjaan pengembangan yang dilakukan pada komputer pengembang. Langkah-langkah awal untuk menyiapkan lingkungan tidak disertakan, karena langkah-langkah tersebut dilakukan sekali saja.

Aplikasi terdiri dari layanan Anda sendiri ditambah pustaka tambahan (dependensi). Berikut ini adalah langkah-langkah dasar yang biasanya Anda ambil saat membangun aplikasi Docker, seperti yang diilustrasikan dalam Gambar 5-1.

Diagram memperlihatkan tujuh langkah yang diperlukan untuk membuat aplikasi dalam kontainer.

Gambar 5-1. Alur kerja langkah demi langkah untuk mengembangkan aplikasi yang dikemas dalam kontainer Docker

Di bagian ini, seluruh proses ini akan dirinci dan setiap langkah utama akan dijelaskan dengan berfokus pada lingkungan Visual Studio.

Saat Anda menggunakan pendekatan pengembangan editor/CLI (misalnya, Visual Studio Code plus CLI Docker di macOS atau Windows), Anda harus mengetahui setiap langkahnya, umumnya secara lebih detail dibandingkan jika menggunakan Visual Studio. Untuk informasi selengkapnya tentang bekerja di lingkungan CLI, lihat e-book siklus hidup Aplikasi Docker yang Dikemas Dalam Kontainer dengan Platform dan Alat Microsoft.

Saat Anda menggunakan Visual Studio 2022 atau yang lebih baru, banyak langkah tersebut ditangani untuk Anda, yang secara dramatis meningkatkan produktivitas Anda. Ini terutama berlaku ketika Anda menargetkan aplikasi multi-kontainer. Misalnya, hanya dengan sekali klik mouse, Visual Studio menambahkan file Dockerfile dan docker-compose.yml ke proyek Anda dengan konfigurasi untuk aplikasi Anda. Ketika Anda menjalankan aplikasi di Visual Studio, aplikasi ini membangun gambar Docker dan menjalankan aplikasi multi-kontainer langsung di Docker; bahkan Anda dapat men-debug beberapa kontainer sekaligus. Fitur-fitur ini akan meningkatkan kecepatan pengembangan Anda.

Tetapi, hanya karena Visual Studio membuat langkah-langkah tersebut secara otomatis tidak berarti bahwa Anda tidak perlu tahu seperti apa prosesnya dengan Docker. Oleh karena itu, panduan berikut merinci setiap langkahnya.

Gambar untuk Langkah 1.

Langkah 1. Mulai pengkodean dan buat aplikasi awal atau garis besar layanan Anda

Mengembangkan aplikasi Docker mirip dengan cara Anda mengembangkan aplikasi tanpa Docker. Perbedaannya adalah saat mengembangkan untuk Docker, Anda menyebarkan dan menguji aplikasi atau layanan yang berjalan dalam kontainer Docker di lingkungan lokal (baik penyiapan mesin virtual Linux oleh Docker atau langsung Windows jika menggunakan kontainer Windows).

Menyiapkan lingkungan lokal Anda dengan Visual Studio

Untuk memulai, pastikan Anda telah memasang Desktop Docker untuk Windows, seperti yang dijelaskan dalam petunjuk berikut:

Mulai menggunakan Docker untuk Windows

Selain itu, Anda memerlukan Visual Studio 2022 atau yang lebih baru dengan beban kerja .ASP.NET dan pengembangan web terinstal, seperti yang ditunjukkan pada Gambar 5-2.

Cuplikan layar pemilihan pengembangan lintas platform .NET Core.

Gambar 5-2. Memilih beban kerja ASP.NET dan pengembangan web selama penyiapan Visual Studio 2022

Anda dapat memulai pengodean aplikasi Anda di .NET biasa (biasanya di .NET Core atau yang lebih baru jika Anda berencana untuk menggunakan kontainer) bahkan sebelum mengaktifkan Docker di aplikasi Anda, dan menyebarkan serta mengujinya di Docker. Tetapi, sebaiknya Anda mulai mengerjakan Docker sesegera mungkin, karena itu akan menjadi lingkungan nyata dan jika ada masalah maka dapat ditemukan sesegera mungkin. Hal ini didorong karena Visual Studio membuatnya sangat mudah untuk bekerja dengan Docker sehingga hampir terasa transparan—contoh terbaik saat men-debug aplikasi multi-kontainer dari Visual Studio.

Sumber Daya Tambahan:

Gambar untuk Langkah 2.

Anda memerlukan Dockerfile untuk setiap gambar kustom yang ingin Anda buat; Anda juga memerlukan Dockerfile untuk setiap kontainer untuk disebarkan, baik Anda menyebarkan secara otomatis dari Visual Studio atau secara manual menggunakan CLI Docker (perintah docker run dan docker-compose). Jika aplikasi Anda berisi satu layanan kustom, Anda hanya perlu satu Dockerfile. Jika aplikasi Anda berisi beberapa layanan (seperti dalam arsitektur layanan mikro), Anda hanya perlu satu Dockerfile untuk setiap layanan.

Dockerfile ditempatkan di folder akar aplikasi atau layanan Anda. Ini berisi perintah yang memberi tahu Docker cara menyiapkan dan menjalankan aplikasi atau layanan Anda dalam kontainer. Anda dapat membuat Dockerfile dalam kode secara manual dan menambahkannya ke proyek Anda bersama dengan dependensi .NET Anda.

Dengan Visual Studio dan alatnya untuk Docker, tugas ini hanya memerlukan beberapa klik. Saat Anda membuat proyek baru di Visual Studio, ada opsi bernama Aktifkan Dukungan Docker, seperti yang ditunjukkan pada Gambar 5-3.

Cuplikan layar memperlihatkan kotak centang Aktifkan Dukungan Docker.

Gambar 5-3. Mengaktifkan Dukungan Docker saat membuat proyek ASP.NET Core baru di Visual Studio 2022

Anda juga dapat mengaktifkan dukungan Docker pada proyek aplikasi web ASP.NET Core yang ada dengan mengeklik kanan proyek di Penjelajah Solusi dan memilih Tambahkan>Dukungan Docker..., seperti yang ditunjukkan pada Gambar 5-4.

Cuplikan layar memperlihatkan opsi Dukungan Docker di menu Tambahkan.

Gambar 5-4. Mengaktifkan dukungan Docker dalam proyek Visual Studio 2022 yang sudah ada

Tindakan ini akan menambahkan Dockerfile ke proyek dengan konfigurasi yang diperlukan, dan hanya tersedia pada proyek ASP.NET Core.

Dengan cara yang sama, Visual Studio juga dapat menambahkan docker-compose.yml file untuk seluruh solusi dengan opsi Tambahkan > Dukungan Orkestrator Kontainer.... Pada langkah 4, kita akan membahas opsi ini secara lebih terperinci.

Menggunakan gambar .NET Docker resmi yang ada

Anda biasanya membuat gambar kustom untuk kontainer Anda di atas gambar dasar yang Anda dapatkan dari repositori resmi seperti registri Hub Docker. Itulah yang terjadi di bawah sampul saat Anda mengaktifkan dukungan Docker di Visual Studio. Dockerfile Anda akan menggunakan gambar dotnet/core/aspnet yang ada.

Sebelumnya kami menjelaskan gambar dan repositori Docker mana yang dapat Anda gunakan, tergantung pada kerangka kerja dan OS yang Telah Anda pilih. Misalnya, jika Anda ingin menggunakan ASP.NET Core (Linux atau Windows), gambar yang akan digunakan adalah mcr.microsoft.com/dotnet/aspnet:8.0. Oleh karena itu, Anda hanya perlu menentukan gambar Docker dasar apa yang akan Anda gunakan untuk kontainer Anda. Anda melakukannya dengan menambahkan FROM mcr.microsoft.com/dotnet/aspnet:8.0 ke Dockerfile Anda. Ini secara otomatis dilakukan oleh Visual Studio, tetapi jika Anda memperbarui versi, Anda memperbarui nilai ini.

Menggunakan repositori gambar .NET resmi dari Hub Docker dengan nomor versi, memastikan bahwa fitur bahasa yang sama tersedia di semua komputer (termasuk pengembangan, pengujian, dan produksi).

Berikut ini menunjukkan contoh Dockerfile untuk kontainer ASP.NET Core.

FROM mcr.microsoft.com/dotnet/aspnet:8.0
ARG source
WORKDIR /app
EXPOSE 80
COPY ${source:-obj/Docker/publish} .
ENTRYPOINT ["dotnet", " MySingleContainerWebApp.dll "]

Dalam hal ini, gambar didasarkan pada versi 8.0 dari gambar resmi ASP.NET Core Docker (multi-arch untuk Linux dan Windows). Ini pengaturan untuk FROM mcr.microsoft.com/dotnet/aspnet:8.0. (Untuk informasi selengkapnya tentang gambar dasar ini, lihat halaman ASP.NET Core Docker Image.) Di Dockerfile, Anda juga harus menginstruksikan Docker untuk mendengarkan port TCP yang akan Anda gunakan saat runtime (dalam kasus ini menggunakan port 80, seperti yang dikonfigurasi dengan pengaturan EXPOSE).

Anda dapat menentukan pengaturan konfigurasi tambahan di Dockerfile, tergantung pada bahasa dan kerangka kerja yang Anda gunakan. Misalnya, baris ENTRYPOINT dengan ["dotnet", "MySingleContainerWebApp.dll"] memberi tahu Docker untuk menjalankan aplikasi .NET. Jika Anda menggunakan SDK dan .NET CLI (dotnet CLI) untuk membangun dan menjalankan aplikasi .NET, pengaturannya akan berbeda. Intinya adalah bahwa baris ENTRYPOINT dan pengaturan lainnya akan berbeda tergantung pada bahasa dan platform yang Anda pilih untuk aplikasi Anda.

Sumber Daya Tambahan:

Menggunakan repositori gambar multi-arch

Satu repositori dapat berisi varian platform, seperti gambar Linux dan gambar Windows. Fitur ini memungkinkan vendor seperti Microsoft (pembuat gambar dasar) membuat repositori tunggal yang mencakup banyak platform (yaitu, Linux dan Windows). Misalnya, repositori .NET yang tersedia di registri Hub Docker menyediakan dukungan untuk Linux dan Windows Nano Server dengan menggunakan nama repositori yang sama.

Jika Anda menentukan tag, menargetkan platform yang eksplisit seperti dalam kasus berikut:

  • mcr.microsoft.com/dotnet/aspnet:8.0-bullseye-slim
    Target: .NET 8 runtime-only di Linux

  • mcr.microsoft.com/dotnet/aspnet:8.0-nanoserver-ltsc2022
    Target: .NET 8 runtime-only di Windows Nano Server

Tetapi, jika Anda menentukan nama gambar yang sama, bahkan dengan tag yang sama, gambar multi-arch (seperti aspnet gambar) akan menggunakan versi Linux atau Windows tergantung pada OS host Docker yangdisebarkan, seperti yang ditunjukkan dalam contoh berikut:

  • mcr.microsoft.com/dotnet/aspnet:8.0
    Multi-arch: .NET 8 runtime-only di Linux atau Windows Nano Server tergantung pada OS host Docker

Dengan cara ini, ketika Anda menarik gambar dari host Windows, itu akan menarik varian Windows, dan menarik nama gambar yang sama dari host Linux akan menarik varian Linux.

Build multi-tahap di Dockerfile

Dockerfile mirip seperti skrip batch. Mirip dengan apa yang akan dilakukan jika Anda harus mengatur mesin dari baris perintah.

Ini dimulai dengan gambar dasar yang mengatur konteks awal, seperti sistem file pengaktifan, yang berada di atas OS host. Ini bukan OS, tetapi Anda dapat menganggapnya seperti OS "di" dalam kontainer.

Eksekusi setiap baris perintah membuat lapisan baru pada sistem file dengan perubahan dari yang sebelumnya, sehingga jika digabungkan dapat menciptakan sistem file yang dihasilkan.

Karena setiap lapisan baru "bertumpu" di atas yang sebelumnya dan ukuran gambar yang dihasilkan meningkat dengan setiap perintah, gambar bisa menjadi sangat besar jika harus menyertakan, misalnya, diperlukan SDK untuk membangun dan menerbitkan aplikasi.

Di sinilah build multi-tahap digunakan ke plot (dari Docker 17.05 dan yang lebih tinggi) untuk melakukan fungsinya.

Inti ide ini adalah Anda dapat memisahkan proses eksekusi Dockerfile secara bertahap, di mana tahap adalah gambar awal diikuti oleh satu atau beberapa perintah, dan tahap terakhir menentukan ukuran gambar akhir.

Singkatnya, build multi-tahap dapat memisahkan pembuatan dalam "fase" yang berbeda, lalu menyusun gambar akhir hanya mengambil direktori yang relevan dari tahapan perantara. Strategi umum untuk menggunakan fitur ini adalah:

  1. Gunakan gambar SDK dasar (tidak masalah seberapa besar), dengan semua yang diperlukan untuk membangun dan menerbitkan aplikasi ke folder lalu

  2. Gunakan gambar dasar, kecil, khusus runtime dan salin folder penerbitan dari tahap sebelumnya untuk menghasilkan gambar akhir kecil.

Mungkin cara terbaik untuk memahami multi-tahap adalah melalui Dockerfile secara terperinci, baris demi baris, jadi mari kita mulai dengan Dockerfile awal yang dibuat oleh Visual Studio saat menambahkan dukungan Docker ke proyek dan nantinya kita akan masuk ke beberapa pengoptimalan.

Dockerfile awal mungkin terlihat seperti ini:

 1  FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
 2  WORKDIR /app
 3  EXPOSE 80
 4
 5  FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
 6  WORKDIR /src
 7  COPY src/Services/Catalog/Catalog.API/Catalog.API.csproj …
 8  COPY src/BuildingBlocks/HealthChecks/src/Microsoft.AspNetCore.HealthChecks …
 9  COPY src/BuildingBlocks/HealthChecks/src/Microsoft.Extensions.HealthChecks …
10  COPY src/BuildingBlocks/EventBus/IntegrationEventLogEF/ …
11  COPY src/BuildingBlocks/EventBus/EventBus/EventBus.csproj …
12  COPY src/BuildingBlocks/EventBus/EventBusRabbitMQ/EventBusRabbitMQ.csproj …
13  COPY src/BuildingBlocks/EventBus/EventBusServiceBus/EventBusServiceBus.csproj …
14  COPY src/BuildingBlocks/WebHostCustomization/WebHost.Customization …
15  COPY src/BuildingBlocks/HealthChecks/src/Microsoft.Extensions …
16  COPY src/BuildingBlocks/HealthChecks/src/Microsoft.Extensions …
17  RUN dotnet restore src/Services/Catalog/Catalog.API/Catalog.API.csproj
18  COPY . .
19  WORKDIR /src/src/Services/Catalog/Catalog.API
20  RUN dotnet build Catalog.API.csproj -c Release -o /app
21
22  FROM build AS publish
23  RUN dotnet publish Catalog.API.csproj -c Release -o /app
24
25  FROM base AS final
26  WORKDIR /app
27  COPY --from=publish /app .
28  ENTRYPOINT ["dotnet", "Catalog.API.dll"]

Dan ini adalah detailnya, baris demi baris:

  • Baris #1: Mulai tahap dengan gambar dasar khusus runtime "kecil", katakanlah sebagai dasar untuk referensi.

  • Baris #2: Buat direktori /app dalam gambar.

  • Baris #3: Mengekspos port 80.

  • Baris #5: Mulai tahap baru dengan gambar "besar" untuk membangun/menerbitkan. Katakanlah sebagai build untuk referensi.

  • Baris #6: Buat direktori /src dalam gambar.

  • Baris #7: Hingga baris 16, salin file proyek .csproj yang direferensikan untuk dapat memulihkan paket nantinya.

  • Baris #17: Pulihkan paket untuk proyek Catalog.API dan proyek yang direferensikan.

  • Baris #18: Salin semua pohon direktori untuk solusi (kecuali file/direktori yang disertakan dalam file .dockerignore) ke direktori /src dalam gambar.

  • Baris #19: Ubah folder saat ini ke proyek Catalog.API.

  • Baris #20: Bangun proyek (dan dependensi proyek lainnya) dan output ke direktori /app dalam gambar.

  • Baris #22: Mulai tahap baru yang berlanjut dari build. Katakanlah terbitkan untuk referensi.

  • Baris #23: Terbitkan proyek (dan dependensi) dan output ke direktori /app dalam gambar.

  • Baris #25: Mulai tahap baru yang berlanjut dari dasar dan sebut saja final.

  • Baris #26: Ubah direktori saat ini ke /app.

  • Baris #27: Salin direktori /app dari tahap penerbitan ke direktori saat ini.

  • Baris #28: Tentukan perintah yang akan dijalankan saat kontainer dimulai.

Sekarang mari kita bahas beberapa pengoptimalan untuk meningkatkan seluruh performa proses dalam kasus eShopOnContainers, berarti sekitar 22 menit atau lebih untuk membangun solusi lengkap dalam kontainer Linux.

Anda akan memanfaatkan fitur cache lapisan Docker, yang cukup sederhana: jika gambar dasar dan perintahnya sama dengan beberapa yang sebelumnya dijalankan, ini cukup menggunakan lapisan yang dihasilkan tanpa perlu menjalankan perintah, sehingga menghemat waktu.

Jadi, mari kita fokus pada tahap build, garis 5-6 sebagian besar sama, tetapi garis 7-17 berbeda untuk setiap layanan dari eShopOnContainers, sehingga harus dieksekusi setiap waktu, namun jika Anda mengubah baris 7-16 menjadi:

COPY . .

Lalu ini akan sama untuk setiap layanan, ini akan menyalin seluruh solusi dan akan membuat lapisan yang lebih besar tetapi:

  1. Proses penyalinan hanya akan dijalankan pertama kali (dan ketika membangun kembali jika file diubah) dan akan menggunakan cache untuk semua layanan lain dan

  2. Karena gambar yang lebih besar terjadi pada tahap perantara, gambar tersebut tidak akan memengaruhi ukuran gambar akhir.

Pengoptimalan signifikan berikutnya melibatkan perintah restore yang dieksekusi di baris 17, ini juga berbeda untuk setiap layanan eShopOnContainers. Jika Anda mengubah baris tersebut menjadi hanya:

RUN dotnet restore

Ini akan memulihkan paket untuk seluruh solusi, tetapi sekali lagi, itu hanya akan dilakukan sekali, alih-alih 15 kali dengan strategi saat ini.

Tetapi, dotnet restore hanya berjalan jika ada satu proyek atau file solusi di folder, jadi untuk mencapainya sedikit lebih rumit dan ada cara untuk menyelesaikannya, tanpa masuk ke terlalu banyak detail, caranya adalah:

  1. Tambahkan baris berikut ke .dockerignore:

    • *.sln, untuk mengabaikan semua file solusi di pohon folder utama

    • !eShopOnContainers-ServicesAndWebApps.sln, untuk menyertakan hanya file solusi ini.

  2. Sertakan argumen /ignoreprojectextensions:.dcproj ke dotnet restore, sehingga juga mengabaikan proyek docker-compose dan hanya memulihkan paket untuk solusi eShopOnContainers-ServicesAndWebApps.

Untuk pengoptimalan akhir, baru saja terjadi bahwa baris 20 berlebihan, karena baris 23 juga membangun aplikasi dan datang, pada dasarnya, tepat setelah baris 20, sehingga ada perintah lain yang memakan waktu.

File yang dihasilkan adalah:

 1  FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
 2  WORKDIR /app
 3  EXPOSE 80
 4
 5  FROM mcr.microsoft.com/dotnet/sdk:8.0 AS publish
 6  WORKDIR /src
 7  COPY . .
 8  RUN dotnet restore /ignoreprojectextensions:.dcproj
 9  WORKDIR /src/src/Services/Catalog/Catalog.API
10  RUN dotnet publish Catalog.API.csproj -c Release -o /app
11
12  FROM base AS final
13  WORKDIR /app
14  COPY --from=publish /app .
15  ENTRYPOINT ["dotnet", "Catalog.API.dll"]

Membuat gambar dasar Anda dari awal

Anda dapat membuat gambar dasar Docker Anda sendiri dari awal. Skenario ini tidak disarankan untuk seseorang yang memulai dengan Docker, tetapi jika Anda ingin mengatur bit tertentu dari gambar dasar Anda sendiri, Anda dapat melakukannya.

Sumber Daya Tambahan:

Gambar untuk Langkah 3.

Langkah 3. Buat gambar Docker kustom Anda dan sematkan aplikasi atau layanan Anda di dalamnya

Untuk setiap layanan dalam aplikasi, Anda perlu membuat gambar terkait. Jika aplikasi Anda terdiri dari satu layanan atau aplikasi web, Anda hanya memerlukan satu gambar.

Perhatikan bahwa gambar Docker dibuat secara otomatis untuk Anda di Visual Studio. Langkah-langkah berikut ini hanya diperlukan untuk alur kerja editor/CLI dan dijelaskan agar lebih mengetahui tentang seperti apa prosesnya.

Sebagai pengembang, Anda harus mengembangkan dan menguji secara lokal sampai Anda mendorong fitur yang selesai atau mengubah ke sistem kontrol sumber Anda (misalnya, untuk GitHub). Ini berarti Anda perlu membuat gambar Docker dan menyebarkan kontainer ke host Docker lokal (Windows atau Linux VM) dan menjalankan, menguji, dan men-debug terhadap kontainer lokal tersebut.

Untuk membuat gambar kustom di lingkungan lokal Anda dengan menggunakan Docker CLI dan Dockerfile, Anda dapat menggunakan perintah build docker, seperti pada Gambar 5-5.

Cuplikan layar memperlihatkan output konsol dari perintah build docker.

Gambar 5-5. Membuat gambar Docker

Secara opsional, alih-alih langsung menjalankan build docker dari folder proyek, Anda dapat terlebih dahulu membuat folder yang dapat disebarkan dengan pustaka dan biner .NET yang dibutuhkan dengan menjalankan dotnet publish, lalu menggunakan perintah docker build.

Ini akan membuat gambar Docker dengan nama cesardl/netcore-webapi-microservice-docker:first. Dalam hal ini, :first adalah tag yang merepresentasikan versi tertentu. Anda dapat mengulangi langkah ini untuk setiap gambar kustom yang harus dibuat untuk aplikasi Docker yang Anda buat.

Ketika aplikasi terbuat dari beberapa kontainer (yaitu, ini adalah aplikasi multi-kontainer), Anda juga dapat menggunakan perintah docker-compose up --build untuk membangun semua gambar terkait dengan satu perintah dengan menggunakan metadata yang diekspos dalam file docker-compose.yml terkait.

Anda dapat menemukan gambar yang ada di repositori lokal Anda dengan menggunakan perintah gambar docker, seperti yang ditunjukkan pada Gambar 5-6.

Output konsol dari gambar docker perintah, memperlihatkan gambar yang ada.

Gambar 5-6. Menampilkan gambar yang ada menggunakan perintah gambar docker

Membuat gambar Docker dengan Visual Studio

Saat Anda menggunakan Visual Studio untuk membuat proyek dengan dukungan Docker, Anda tidak secara jelas membuat sebuah gambar. Sebagai gantinya, gambar dibuat untuk Anda saat Anda menekan F5 (atau Ctrl+F5) untuk menjalankan aplikasi atau layanan yang di-docker. Langkah ini otomatis dalam Visual Studio dan Anda tidak akan melihatnya terjadi, tetapi penting bahwa Anda mengetahui seperti apa prosesnya.

Gambar untuk Langkah 4 opsional.

Langkah 4. Tentukan layanan Anda di docker-compose.yml saat membangun aplikasi Docker multi-kontainer

File docker-compose.yml memungkinkan Anda menentukan sekumpulan layanan terkait untuk disebarkan sebagai aplikasi yang dibuat dengan perintah penyebaran. Ini juga mengonfigurasi hubungan dependensi dan konfigurasi runtime.

Untuk menggunakan file docker-compose.yml, Anda harus membuat file di folder solusi utama atau akar Anda, dengan konten yang mirip dengan itu dalam contoh berikut:

version: '3.4'

services:

  webmvc:
    image: eshop/web
    environment:
      - CatalogUrl=http://catalog-api
      - OrderingUrl=http://ordering-api
    ports:
      - "80:80"
    depends_on:
      - catalog-api
      - ordering-api

  catalog-api:
    image: eshop/catalog-api
    environment:
      - ConnectionString=Server=sqldata;Port=1433;Database=CatalogDB;…
    ports:
      - "81:80"
    depends_on:
      - sqldata

  ordering-api:
    image: eshop/ordering-api
    environment:
      - ConnectionString=Server=sqldata;Database=OrderingDb;…
    ports:
      - "82:80"
    extra_hosts:
      - "CESARDLBOOKVHD:10.0.75.1"
    depends_on:
      - sqldata

  sqldata:
    image: mcr.microsoft.com/mssql/server:latest
    environment:
      - SA_PASSWORD=[PLACEHOLDER]
      - ACCEPT_EULA=Y
    ports:
      - "5433:1433"

Penting

Microsoft menyarankan agar Anda menggunakan alur autentikasi paling aman yang tersedia. Jika Anda menyambungkan ke Azure SQL, Identitas Terkelola untuk sumber daya Azure adalah metode autentikasi yang direkomendasikan.

File docker-compose.yml ini adalah versi yang disederhanakan dan digabungkan. File ini berisi data konfigurasi statis untuk setiap kontainer (seperti nama gambar kustom), yang selalu diperlukan, dan informasi konfigurasi yang mungkin bergantung pada lingkungan penyebaran, seperti string koneksi. Di bagian selanjutnya, Anda akan mempelajari cara membagi konfigurasi docker-compose.yml menjadi beberapa file docker-compose dan mengambil alih nilai tergantung pada lingkungan dan jenis eksekusi (debug atau rilis).

Contoh file docker-compose.yml menentukan empat layanan: layanan webmvc (aplikasi web), dua layanan mikro (ordering-api dan ), dan basket-apisatu kontainer sumber data, sqldata, berdasarkan SQL Server untuk Linux yang berjalan sebagai kontainer. Setiap layanan akan disebarkan sebagai kontainer, sehingga gambar Docker diperlukan untuk masing-masing layanan.

File docker-compose.yml tidak hanya menentukan kontainer apa yang digunakan, tetapi bagaimana kontainer dikonfigurasi secara individual. Misalnya, definisi kontainer webmvc dalam file .yml:

  • Menggunakan gambar eshop/web:latest bawaan. Tetapi, Anda juga dapat mengonfigurasi gambar yang akan dibangun sebagai bagian dari eksekusi docker-compose dengan konfigurasi tambahan berdasarkan build: bagian dalam file docker-compose.

  • Menginisialisasi dua variabel lingkungan (CatalogUrl dan OrderingUrl).

  • Meneruskan port 80 yang diekspos pada kontainer ke port eksternal 80 pada komputer host.

  • Menautkan aplikasi web ke katalog dan layanan pemesanan dengan pengaturan depends_on. Hal ini menyebabkan layanan menunggu hingga layanan tersebut dimulai.

Kita akan membahas kembali file docker-compose.yml di bagian selanjutnya ketika membahas cara menerapkan layanan mikro dan aplikasi multi-kontainer.

Bekerja dengan docker-compose.yml di Visual Studio

Selain menambahkan Dockerfile ke proyek, seperti yang kami sebutkan sebelumnya, Visual Studio 2017 (dari versi 15.8 aktif) dapat menambahkan dukungan orkestrator untuk Docker Compose ke solusi.

Saat Anda menambahkan dukungan orkestrator kontainer, seperti yang ditunjukkan pada Gambar 5-7, untuk pertama kalinya, Visual Studio membuat Dockerfile untuk proyek dan membuat proyek (bagian layanan) baru dalam solusi Anda dengan beberapa file docker-compose*.yml global, lalu menambahkan proyek ke file tersebut. Kemudian Anda dapat membuka file docker-compose.yml dan memperbaruinya dengan fitur tambahan.

Ulangi operasi ini untuk setiap proyek yang ingin Anda sertakan dalam file docker-compose.yml.

Pada saat ini ditulis, Visual Studio mendukung orkestrator Docker Compose.

Cuplikan layar memperlihatkan opsi Dukungan Orkestrator Kontainer di menu konteks proyek.

Gambar 5-7. Menambahkan dukungan Docker di Visual Studio 2022 dengan mengeklik kanan proyek ASP.NET Core

Setelah Anda menambahkan dukungan orkestrator ke solusi Anda di Visual Studio, Anda juga akan melihat simpul baru (dalam file proyek docker-compose.dcproj) di Penjelajah Solusi yang berisi file tambahan docker-compose.yml, seperti yang ditunjukkan pada Gambar 5-8.

Cuplikan layar simpul docker-compose di Penjelajah Solusi.

Gambar 5-8. Node pohon docker-compose ditambahkan pada Penjelajah Solusi Visual Studio 2022

Anda dapat menyebarkan aplikasi multi-kontainer dengan satu file docker-compose.yml dengan menggunakan perintah docker-compose up. Tetapi, Visual Studio menambahkan sekelompoknya sehingga Anda dapat mengambil alih nilai tergantung pada lingkungan (pengembangan atau produksi) dan jenis eksekusi (rilis atau debug). Kemampuan ini akan dijelaskan di bagian selanjutnya.

Gambar untuk Langkah 5.

Langkah 5. Membangun dan menjalankan aplikasi Docker Anda

Jika aplikasi Anda hanya memiliki satu kontainer, Anda dapat menjalankannya dengan menyebarkannya ke host Docker Anda (VM atau server fisik). Tetapi, jika aplikasi Anda berisi beberapa layanan, Anda dapat menyebarkannya sebagai aplikasi yang ditulis, baik menggunakan satu perintah CLI (docker-compose up), atau dengan Visual Studio, yang akan menggunakan perintah tersebut di latar belakang. Mari kita lihat opsi lainnya.

Opsi A: Menjalankan aplikasi kontainer tunggal

Menggunakan Docker CLI

Anda dapat menjalankan kontainer Docker menggunakan perintah docker run, seperti yang ditunjukkan pada Gambar 5-9:

docker run -t -d -p 80:5000 cesardl/netcore-webapi-microservice-docker:first

Perintah di atas akan membuat instans kontainer baru dari gambar yang ditentukan, setiap kali dijalankan. Anda dapat menggunakan parameter --name untuk memberikan nama ke kontainer lalu menggunakan docker start {name} (atau menggunakan ID kontainer atau nama otomatis) untuk menjalankan instans kontainer yang ada.

Cuplikan layar menjalankan kontainer Docker menggunakan perintah jalankan docker.

Gambar 5-9. Menjalankan kontainer Docker menggunakan perintah docker run

Dalam hal ini, perintah mengikat port internal 5000 kontainer ke port 80 komputer host. Ini berarti bahwa host mendengarkan di port 80 dan meneruskan ke port 5000 pada kontainer.

Hash yang ditampilkan adalah ID kontainer dan juga diberi nama acak yang dapat dibaca jika opsi --name tidak digunakan.

Menggunakan Visual Studio

Jika Anda belum menambahkan dukungan orkestrator kontainer, Anda juga dapat menjalankan satu aplikasi kontainer di Visual Studio dengan menekan Ctrl+F5 dan Anda juga dapat menggunakan F5 untuk men-debug aplikasi dalam kontainer. Kontainer berjalan secara lokal menggunakan docker run.

Opsi B: Menjalankan aplikasi multi-kontainer

Dalam sebagian besar skenario perusahaan, aplikasi Docker akan terdiri dari beberapa layanan, ini berarti Anda harus menjalankan aplikasi multi-kontainer, seperti yang ditunjukkan pada Gambar 5-10.

VM dengan beberapa kontainer Docker

Gambar 5-10. Mesin virtual dengan kontainer Docker disebarkan

Menggunakan Docker CLI

Untuk menjalankan aplikasi multi-kontainer dengan Docker CLI, Anda menggunakan perintah docker-compose up. Perintah ini menggunakan file docker-compose.yml yang Anda miliki di tingkat solusi untuk menyebarkan aplikasi multi-kontainer. Gambar 5-11 menunjukkan hasil saat menjalankan perintah dari direktori solusi utama Anda, ini berisi file docker-compose.yml.

Tampilan layar saat menjalankan perintah docker-compose up

Gambar 5-11. Contoh hasil saat menjalankan perintah docker-compose up

Setelah perintah docker-compose up berjalan, aplikasi dan kontainer terkait disebarkan ke host Docker Anda, seperti dijelaskan dalam Gambar 5-10.

Menggunakan Visual Studio

Menjalankan aplikasi multi-kontainer menggunakan Visual Studio 2019 tidak bisa menjadi lebih sederhana. Anda cukup menekan Ctrl+F5 untuk menjalankan atau F5 untuk men-debug, seperti biasa, menyiapkan proyek docker-compose sebagai proyek startup. Visual Studio menangani semua pengaturan yang dibutuhkan, sehingga Anda dapat membuat titik henti seperti biasa dan men-debug yang akhirnya menjadi proses independen yang berjalan di "server jarak jauh", dengan debugger sudah terpasang, seperti itu.

Seperti disebutkan sebelumnya, setiap kali Anda menambahkan dukungan solusi Docker ke proyek dalam solusi, proyek tersebut dikonfigurasi dalam file docker-compose.yml global (tingkat solusi), hal ini memungkinkan Anda menjalankan atau men-debug seluruh solusi sekaligus. Visual Studio akan memulai satu kontainer untuk setiap proyek yang mengaktifkan dukungan solusi Docker, dan melakukan semua langkah internal untuk Anda (penerbitan dotnet, build docker, dll.).

Jika Anda ingin melihat semua pekerjaan, lihat file:

{root solution folder}\obj\Docker\docker-compose.vs.debug.g.yml

Poin pentingnya adalah bahwa seperti yang ditunjukkan pada Gambar 5-12, pada Visual Studio 2019 ada perintah Docker tambahan untuk tindakan kunci F5. Opsi ini memungkinkan Anda menjalankan atau men-debug aplikasi multi-kontainer dengan menjalankan semua kontainer yang ditentukan dalam file docker-compose.yml di tingkat solusi. Kemampuan untuk men-debug solusi beberapa kontainer berarti Anda dapat mengatur beberapa titik henti, setiap titik henti dalam proyek (kontainer) yang berbeda, dan sementara penelusuran kesalahan dari Visual Studio Anda akan berhenti pada titik henti yang ditentukan dalam proyek yang berbeda dan berjalan pada kontainer yang berbeda.

Cuplikan layar toolbar debug yang menjalankan proyek docker-compose.

Gambar 5-12. Menjalankan aplikasi multi-kontainer di Visual Studio 2022

Sumber Daya Tambahan:

Catatan tentang pengujian dan penyebaran dengan orkestrator

Perintah docker-compose up dan docker run (atau menjalankan dan men-debug kontainer di Visual Studio) memadai untuk menguji kontainer di lingkungan pengembangan Anda. Tetapi Anda tidak boleh menggunakan pendekatan ini untuk penyebaran produksi, di mana Anda harus menargetkan orkestrator seperti Kubernetes atau Service Fabric. Jika menggunakan Kubernetes, Anda harus menggunakan pod untuk mengatur kontainer dan layanan untuk jaringannya. Anda juga menggunakan penyebaran untuk mengatur pembuatan dan modifikasi pod.

Gambar untuk Langkah 6.

Langkah 6. Menguji aplikasi Docker Anda menggunakan host Docker lokal Anda

Langkah ini akan bervariasi tergantung pada apa yang dilakukan oleh aplikasi Anda. Dalam aplikasi Web .NET sederhana yang disebarkan sebagai kontainer atau layanan tunggal, Anda dapat mengakses layanan dengan membuka browser di host Docker dan menavigasi ke situs tersebut, seperti yang ditunjukkan pada Gambar 5-13. (Jika konfigurasi di Dockerfile memetakan kontainer ke port pada host selain 80, sertakan port host di URL.)

Cuplikan layar respons dari localhost/API/values.

Gambar 5-13. Contoh pengujian aplikasi Docker Anda secara lokal menggunakan localhost

Jika localhost tidak menunjuk ke IP host Docker (secara default, saat menggunakan Docker CE, seharusnya), untuk menavigasi ke layanan Anda, gunakan alamat IP kartu jaringan komputer Anda.

URL di browser ini menggunakan port 80 untuk contoh kontainer tertentu yang sedang dibahas. Namun, secara internal permintaan dialihkan ke port 5000, karena itulah cara penyebarannya dengan perintah docker run, seperti yang dijelaskan pada langkah sebelumnya.

Anda juga dapat menguji aplikasi menggunakan curl dari terminal, seperti yang ditunjukkan pada Gambar 5-14. Dalam penginstalan Docker di Windows, IP Host Docker default selalu 10.0.75.1 selain alamat IP mesin Anda yang sebenarnya.

Output konsol dari mendapatkan http://10.0.75.1/API/values dengan curl.

Gambar 5-14. Contoh pengujian aplikasi Docker Anda secara lokal menggunakan curl

Menguji dan men-debug kontainer dengan Visual Studio

Saat menjalankan dan men-debug kontainer dengan Visual Studio, Anda dapat men-debug aplikasi .NET dengan cara yang sama seperti yang Anda lakukan saat berjalan tanpa kontainer.

Pengujian dan penelusuran kesalahan tanpa Visual Studio

Jika Anda mengembangkan menggunakan pendekatan editor/CLI, men-debug kontainer lebih sulit dan Anda mungkin ingin men-debug dengan menghasilkan jejak.

Sumber Daya Tambahan:

Alur kerja yang disederhanakan saat mengembangkan kontainer dengan Visual Studio

Secara efektif, alur kerja saat menggunakan Visual Studio jauh lebih sederhana dibandingkan jika Anda menggunakan pendekatan editor/CLI. Sebagian besar langkah yang diperlukan oleh Docker yang terkait dengan file Dockerfile dan docker-compose.yml disembunyikan atau disederhanakan oleh Visual Studio, seperti yang ditunjukkan pada Gambar 5-15.

Diagram memperlihatkan lima langkah yang disederhanakan yang diperlukan untuk membuat aplikasi.

Gambar 5-15. Alur kerja sederhana saat mengembangkan kontainer dengan Visual Studio

Selain itu, Anda harus melakukan langkah 2 (menambahkan dukungan Docker ke proyek Anda) hanya sekali. Oleh karena itu, alur kerja mirip dengan tugas pengembangan Anda yang biasa saat menggunakan .NET untuk pengembangan lainnya. Anda perlu tahu apa yang terjadi di bawah sampul (proses build gambar, gambar dasar apa yang Anda gunakan, penyebaran kontainer, dll.) dan kadang-kadang Anda juga perlu mengedit file Dockerfile atau docker-compose.yml untuk menyesuaikan perilaku. Tetapi sebagian besar pekerjaan sangat disederhanakan dengan menggunakan Visual Studio, membuat Anda jauh lebih produktif.

Menggunakan perintah PowerShell di Dockerfile untuk menyiapkan kontainer Windows

Kontainer Windows memungkinkan Anda mengonversi aplikasi Windows yang ada menjadi gambar Docker dan menyebarkannya dengan alat yang sama dengan ekosistem Docker lainnya. Untuk menggunakan Windows Containers, Anda menjalankan perintah PowerShell di Dockerfile, seperti yang ditunjukkan dalam contoh berikut:

FROM mcr.microsoft.com/windows/servercore
LABEL Description="IIS" Vendor="Microsoft" Version="10"
RUN powershell -Command Add-WindowsFeature Web-Server
CMD [ "ping", "localhost", "-t" ]

Dalam hal ini, kita menggunakan gambar dasar Windows Server Core (pengaturan FROM) dan memasangl IIS dengan perintah PowerShell (pengaturan RUN). Dengan cara yang sama, Anda juga dapat menggunakan perintah PowerShell untuk menyiapkan komponen tambahan seperti ASP.NET 4.x, .NET Framework 4.6, atau perangkat lunak Windows lainnya. Misalnya, perintah berikut dalam Dockerfile menyiapkan ASP.NET 4.5:

RUN powershell add-windowsfeature web-asp-net45

Sumber Daya Tambahan:

SebelumnyaBerikutnya

  • Last updated on