Samouczek: tworzenie aplikacji z wieloma kontenerami za pomocą narzędzia Docker Compose

Z tego samouczka dowiesz się, jak zarządzać więcej niż jednym kontenerem i komunikować się między nimi podczas korzystania z narzędzi kontenerów w programie Visual Studio. Zarządzanie wieloma kontenerami wymaga orkiestracji kontenerów i wymaga orkiestratora, takiego jak Docker Compose lub Service Fabric. W przypadku tych procedur należy użyć narzędzia Docker Compose. Narzędzie Docker Compose doskonale nadaje się do lokalnego debugowania i testowania w trakcie cyklu programowania.

Ukończony przykład utworzony w tym samouczku można znaleźć w witrynie GitHub w https://github.com/MicrosoftDocs/vs-tutorial-samples folderze docker/ComposeSample.

Wymagania wstępne

• Docker Desktop
• Program Visual Studio 2022 z zainstalowanym pakietem roboczym Tworzenie aplikacji internetowych, narzędzi platformy Azure i/lub pakietem roboczym programowania dla wielu platform .NET. Ta instalacja obejmuje narzędzia programistyczne platformy .NET 8.

Tworzenie projektu aplikacji internetowej

W programie Visual Studio utwórz projekt aplikacji internetowej ASP.NET Core o nazwie WebFrontEnd, aby utworzyć aplikację internetową ze stronami Razor.

Uwaga

W programie Visual Studio 2022 17.2 lub nowszym możesz zamiast tego użyć usługi Azure Functions.

Nie wybieraj pozycji Włącz obsługę platformy Docker. W dalszej części tego procesu dodasz obsługę platformy Docker.

Tworzenie projektu internetowego interfejsu API

1. Dodaj projekt do tego samego rozwiązania i wywołaj go interfejs WebAPI. Wybierz interfejs API jako typ projektu i usuń zaznaczenie pola wyboru Konfigurowanie dla protokołu HTTPS. W tym projekcie używamy tylko protokołu SSL do komunikacji z klientem, a nie komunikacji między kontenerami w tej samej aplikacji internetowej. Wymaga tylko WebFrontEnd protokołu HTTPS i kodu w przykładach założono, że to pole wyboru zostało wyczyszczone. Ogólnie rzecz biorąc, certyfikaty dla deweloperów platformy .NET używane przez program Visual Studio są obsługiwane tylko w przypadku żądań zewnętrznych do kontenerów, a nie dla żądań kontenera do kontenera.

   

2. Dodano obsługę pamięci podręcznej Redis Cache. Dodaj pakiet Microsoft.Extensions.Caching.StackExchangeRedis NuGet (nie StackExchange.Redis). W pliku Program.cs dodaj następujące wiersze tuż przed var app = builder.Build():

   builder.Services.AddStackExchangeRedisCache(options =>
      {
         options.Configuration = "redis:6379"; // redis is the container name of the redis service. 6379 is the default port
         options.InstanceName = "SampleInstance";
      });
   

3. Dodaj dyrektywy using w pliku Program.cs for Microsoft.Extensions.Caching.Distributed i Microsoft.Extensions.Caching.StackExchangeRedis.

   using Microsoft.Extensions.Caching.Distributed;
   using Microsoft.Extensions.Caching.StackExchangeRedis;
   

4. W projekcie internetowego interfejsu API usuń istniejący plik WeatherForecast.cs i Controllers/WeatherForecastController.cs, a następnie dodaj plik w pliku Controllers, CounterController.cs z następującą zawartością:

   using Microsoft.AspNetCore.Mvc;
   using Microsoft.Extensions.Caching.Distributed;
   using StackExchange.Redis;
   
   namespace WebApi.Controllers
   {
       [ApiController]
       [Route("[controller]")]
       public class CounterController : ControllerBase
       {
           private readonly ILogger<CounterController> _logger;
           private readonly IDistributedCache _cache;
   
           public CounterController(ILogger<CounterController> logger, IDistributedCache cache)
           {
               _logger = logger;
               _cache = cache;
           }
   
           [HttpGet(Name = "GetCounter")]
           public string Get()
           {
               string key = "Counter";
               string? result = null;
               try
               {
                   var counterStr = _cache.GetString(key);
                   if (int.TryParse(counterStr, out int counter))
                   {
                       counter++;
                   }
                   else
                   {
                       counter = 0;
                   }
                   result = counter.ToString();
                   _cache.SetString(key, result);
               }
               catch(RedisConnectionException)
               {
                   result = "Redis cache is not found.";
               }
               return result;
           }
       }
   }
   

   Usługa zwiększa licznik za każdym razem, gdy strona jest uzyskiwana i przechowuje licznik w pamięci podręcznej Redis Cache.

Dodawanie kodu w celu wywołania internetowego interfejsu API

1. W projekcie WebFrontEnd otwórz plik Index.cshtml.cs i zastąp metodę OnGet następującym kodem.

   public async Task OnGet()
   {
      using (var client = new System.Net.Http.HttpClient())
      {
         // Call *mywebapi*, and display its response in the page
         var request = new System.Net.Http.HttpRequestMessage();
         // webapi is the container name
         request.RequestUri = new Uri("http://webapi/Counter");
         var response = await client.SendAsync(request);
         string counter = await response.Content.ReadAsStringAsync();
         ViewData["Message"] = $"Counter value from cache :{counter}";
      }
   }
   

   Uwaga

   W rzeczywistym kodzie nie należy usuwać HttpClient po każdym żądaniu. Aby uzyskać najlepsze rozwiązania, zobacz Implementowanie odpornych żądań HTTP za pomocą elementu HttpClientFactory.

2. W pliku Index.cshtml dodaj wiersz do wyświetleniaViewData["Message"], aby plik wyglądał podobnie do następującego kodu:

   @page
   @model IndexModel
   @{
       ViewData["Title"] = "Home page";
   }
   
   <div class="text-center">
       <h1 class="display-4">Welcome</h1>
       <p>Learn about <a href="/aspnet/core">building Web apps with ASP.NET Core</a>.</p>
       <p>@ViewData["Message"]</p>
   </div>
   

   Ten kod wyświetla wartość licznika zwróconego z projektu internetowego interfejsu API.

Dodawanie obsługi narzędzia Docker Compose

1. W projekcie WebFrontEnd wybierz pozycję Dodaj > obsługę orkiestratora kontenerów. Zostanie wyświetlone okno dialogowe Opcje pomocy technicznej platformy Docker.

2. Wybierz pozycję Docker Compose.

3. Wybierz docelowy system operacyjny, na przykład Linux.

   

   Program Visual Studio tworzy plik docker-compose.yml i plik .dockerignore w węźle docker-compose w rozwiązaniu, a projekt pokazuje czcionkę pogrubienia, która pokazuje, że jest to projekt startowy.

   

   Plik docker-compose.yml jest wyświetlany w następujący sposób:

   version: '3.4'
   
    services:
      webfrontend:
        image: ${DOCKER_REGISTRY-}webfrontend
        build:
          context: .
          dockerfile: WebFrontEnd/Dockerfile
   

   Określony version w pierwszym wierszu jest wersja pliku Docker Compose. Zwykle nie należy go zmieniać, ponieważ jest on używany przez narzędzia do zrozumienia sposobu interpretowania pliku.

   Plik .dockerignore zawiera typy plików i rozszerzenia, których nie chcesz dołączać do kontenera do platformy Docker. Te pliki są zwykle kojarzone ze środowiskiem projektowym i kontrolą źródła, a nie częścią tworzonej aplikacji lub usługi.

   Zapoznaj się z sekcją Narzędzia kontenera w okienku danych wyjściowych, aby uzyskać szczegółowe informacje o uruchamianych poleceniach. Możesz zobaczyć, że narzędzie wiersza polecenia docker-compose służy do konfigurowania i tworzenia kontenerów środowiska uruchomieniowego.

4. W projekcie internetowego interfejsu API ponownie kliknij prawym przyciskiem myszy węzeł projektu i wybierz polecenie Dodaj>obsługę orkiestratora kontenerów. Wybierz pozycję Docker Compose, a następnie wybierz ten sam docelowy system operacyjny.

   Uwaga

   W tym kroku program Visual Studio będzie oferować tworzenie pliku Dockerfile. Jeśli zrobisz to w projekcie, który ma już obsługę platformy Docker, zostanie wyświetlony monit o zastąpienie istniejącego pliku Dockerfile. Jeśli wprowadzono zmiany w pliku Dockerfile, które chcesz zachować, wybierz pozycję Nie.

   Program Visual Studio wprowadza pewne zmiany w pliku docker compose YML. Teraz oba usługi są uwzględniane.

   version: '3.4'
   
   services:
     webfrontend:
       image: ${DOCKER_REGISTRY-}webfrontend
       build:
         context: .
         dockerfile: WebFrontEnd/Dockerfile
   
     mywebapi:
       image: ${DOCKER_REGISTRY-}mywebapi
       build:
         context: .
         dockerfile: MyWebAPI/Dockerfile
   

5. Dodaj pamięć podręczną docker.compose.yml Redis Cache do pliku:

   redis:
      image: redis
   

   Upewnij się, że wcięcie znajduje się na tym samym poziomie co pozostałe dwie usługi.

6. Pierwszy projekt, do którego dodajesz orkiestrację kontenerów, jest skonfigurowany do uruchomienia podczas uruchamiania lub debugowania. Możesz skonfigurować akcję uruchamiania we właściwościach projektu dla projektu docker-compose. W węźle projektu docker-compose kliknij prawym przyciskiem myszy, aby otworzyć menu kontekstowe, a następnie wybierz polecenie Właściwości lub użyj klawisza Alt+Enter. Można na przykład zmienić stronę ładowaną przez dostosowanie właściwości Adres URL usługi.

   

7. Naciśnij klawisz F5. Oto, co widzisz po uruchomieniu:

   

8. Kontenery można monitorować za pomocą okna Kontenery . Jeśli nie widzisz okna, użyj pola wyszukiwania, naciśnij klawisze Ctrl K, Ctrl++O lub naciśnij klawisze Ctrl+Q. W obszarze Wyszukiwanie funkcji wyszukaj ciąg containers, a następnie wybierz pozycję Wyświetl>inne kontenery systemu Windows>z listy.

9. Rozwiń węzeł Kontenery rozwiązań i wybierz węzeł projektu Docker Compose, aby wyświetlić połączone dzienniki na karcie Dzienniki tego okna.

   

   Możesz również wybrać węzeł dla pojedynczego kontenera, aby wyświetlić dzienniki, zmienne środowiskowe, system plików i inne szczegóły.

Konfigurowanie profilów uruchamiania

1. To rozwiązanie ma pamięć podręczną Redis Cache, ale nie jest wydajne ponowne kompilowanie kontenera pamięci podręcznej Redis za każdym razem, gdy rozpoczynasz sesję debugowania. Aby uniknąć takiej sytuacji, możesz skonfigurować kilka profilów uruchamiania. Utwórz jeden profil, aby uruchomić pamięć podręczną Redis Cache. Utwórz drugi profil, aby uruchomić inne usługi. Drugi profil może używać kontenera pamięci podręcznej Redis Cache, który jest już uruchomiony. Na pasku menu możesz użyć listy rozwijanej obok przycisku Start, aby otworzyć menu z opcjami debugowania. Wybierz pozycję Zarządzaj Ustawienia uruchamiania platformy Docker Compose.

   

   Zostanie wyświetlone okno dialogowe Zarządzanie Ustawienia uruchamiania platformy Docker Compose. Za pomocą tego okna dialogowego można kontrolować, który podzbiór usług jest uruchamiany podczas sesji debugowania, która jest uruchamiana z dołączonym debugerem lub bez niego, oraz usługę uruchamiania i adres URL. Zobacz Uruchamianie podzestawu usług Compose.

   

   Wybierz pozycję Nowy , aby utworzyć nowy profil i nadaj mu Start Redisnazwę . Następnie ustaw kontener Redis na Uruchom bez debugowania, pozostaw drugi ustawiony na Nie uruchamiaj, a następnie wybierz pozycję Zapisz.

   

   Następnie utwórz inny profil Start My Services , który nie uruchamia usługi Redis, ale uruchamia pozostałe dwie usługi.

   

   (Opcjonalnie) Utwórz trzeci profil Start All , aby uruchomić wszystko. Możesz wybrać pozycję Rozpocznij bez debugowania dla usługi Redis.

2. Wybierz pozycję Uruchom usługę Redis z listy rozwijanej na głównym pasku narzędzi programu Visual Studio, naciśnij klawisz F5. Kontener Redis kompiluje i uruchamia. Możesz użyć okna Kontenery , aby zobaczyć, że jest uruchomiony. Następnie wybierz pozycję Uruchom moje usługi z listy rozwijanej i naciśnij klawisz F5 , aby je uruchomić. Teraz możesz zachować działanie kontenera pamięci podręcznej Redis Cache w wielu kolejnych sesjach debugowania. Za każdym razem, gdy używasz usługi Start My Services, te usługi używają tego samego kontenera pamięci podręcznej Redis.

Gratulacje, uruchamiasz aplikację Docker Compose z niestandardowym profilem narzędzia Docker Compose.

Następne kroki

Zapoznaj się z opcjami wdrażania kontenerów na platformie Azure.

Zobacz też

Docker Compose
Narzędzia kontenerów