Wdrażanie i usuwanie aplikacji przy użyciu elementu FabricClient

  • Artykuł

Po spakowanym typie aplikacji można przystąpić do wdrażania w klastrze usługi Azure Service Fabric. Wdrożenie obejmuje następujące trzy kroki:

  1. Przekazywanie pakietu aplikacji do magazynu obrazów
  2. Rejestrowanie typu aplikacji
  3. Usuwanie pakietu aplikacji z magazynu obrazów
  4. Tworzenie wystąpienia aplikacji

Po wdrożeniu aplikacji i uruchomieniu wystąpienia w klastrze można usunąć wystąpienie aplikacji i jego typ. Całkowicie usuń aplikację z klastra, wykonując następujące kroki:

  1. Usuwanie (lub usuwanie) uruchomionego wystąpienia aplikacji
  2. Wyrejestrowywanie typu aplikacji, jeśli nie jest już potrzebne

Jeśli używasz programu Visual Studio do wdrażania i debugowania aplikacji w lokalnym klastrze deweloperów, wszystkie powyższe kroki są obsługiwane automatycznie za pomocą skryptu programu PowerShell. Ten skrypt znajduje się w folderze Scripts projektu aplikacji. Ten artykuł zawiera podstawowe informacje na temat tego, co robi ten skrypt, dzięki czemu można wykonywać te same operacje poza programem Visual Studio.

Łączenie z klastrem

Połączenie do klastra przez utworzenie obiektu Wystąpienie FabricClient przed uruchomieniem któregokolwiek z przykładów kodu w tym artykule. Przykłady nawiązywania połączenia z lokalnym klastrem programistycznym lub klastrem zdalnym lub klastrem zabezpieczonym przy użyciu certyfikatów Microsoft Entra ID, X509 lub Usługi Active Directory systemu Windows można znaleźć Połączenie z bezpiecznym klastrem. Aby nawiązać połączenie z lokalnym klastrem programistycznym, uruchom następujący przykład:

// Connect to the local cluster.
FabricClient fabricClient = new FabricClient();

Przekazywanie pakietu aplikacji

Załóżmy, że tworzysz i pakujesz aplikację o nazwie MyApplication w programie Visual Studio. Domyślnie nazwa typu aplikacji wyświetlana w pliku ApplicationManifest.xml to "MyApplicationType". Pakiet aplikacji, który zawiera niezbędny manifest aplikacji, manifesty usługi i kod/config/data packages, znajduje się w folderze C:\Users< username>\Documents\Visual Studio 2019\Projects\MyApplication\MyApplication\pkg\Debug.

Przekazanie pakietu aplikacji umieszcza go w lokalizacji dostępnej dla wewnętrznych składników usługi Service Fabric. Usługa Service Fabric weryfikuje pakiet aplikacji podczas rejestracji pakietu aplikacji. Jeśli jednak chcesz zweryfikować pakiet aplikacji lokalnie (tj. przed przekazaniem), użyj polecenia cmdlet Test-ServiceFabricApplicationPackage .

Interfejs API CopyApplicationPackage przekazuje pakiet aplikacji do magazynu obrazów klastra.

Jeśli pakiet aplikacji jest duży i/lub zawiera wiele plików, możesz go skompresować i skopiować do magazynu obrazów przy użyciu programu PowerShell. Kompresja zmniejsza rozmiar i liczbę plików.

Aby uzyskać dodatkowe informacje na temat magazynu obrazów i magazynu obrazów parametry połączenia, zobacz Omówienie magazynu obrazów parametry połączenia.

Rejestrowanie pakietu aplikacji

Typ aplikacji i wersja zadeklarowana w manifeście aplikacji stają się dostępne do użycia podczas rejestrowania pakietu aplikacji. System odczytuje pakiet przekazany w poprzednim kroku, weryfikuje pakiet, przetwarza zawartość pakietu i kopiuje przetworzony pakiet do wewnętrznej lokalizacji systemu.

Interfejs API ProvisionApplicationAsync rejestruje typ aplikacji w klastrze i udostępnia go do wdrożenia.

Interfejs API GetApplicationTypeListAsync zawiera informacje o wszystkich pomyślnie zarejestrowanych typach aplikacji. Tego interfejsu API można użyć do określenia, kiedy rejestracja jest wykonywana.

Usuwanie pakietu aplikacji z magazynu obrazów

Zaleca się usunięcie pakietu aplikacji po pomyślnym zarejestrowaniu aplikacji. Usuwanie pakietów aplikacji z magazynu obrazów zwalnia zasoby systemowe. Przechowywanie nieużywanych pakietów aplikacji zużywa magazyn dysku i prowadzi do problemów z wydajnością aplikacji. Usuń pakiet aplikacji z magazynu obrazów przy użyciu interfejsu API RemoveApplicationPackage .

Tworzenie wystąpienia aplikacji

Możesz utworzyć wystąpienie aplikacji z dowolnego typu aplikacji, który został pomyślnie zarejestrowany przy użyciu interfejsu API CreateApplicationAsync . Nazwa każdej aplikacji musi zaczynać się od schematu "fabric:" i musi być unikatowa dla każdego wystąpienia aplikacji (w klastrze). Tworzone są również wszystkie usługi domyślne zdefiniowane w manifeście aplikacji docelowej.

Dla dowolnej wersji zarejestrowanego typu aplikacji można utworzyć wiele wystąpień aplikacji. Każde wystąpienie aplikacji działa w izolacji z własnym katalogiem roboczym i zestawem procesów.

Aby sprawdzić, które nazwane aplikacje i usługi są uruchomione w klastrze, uruchom interfejsy API GetApplicationListAsync i GetServiceListAsync .

Tworzenie wystąpienia usługi

Wystąpienie usługi można utworzyć na podstawie typu usługi przy użyciu interfejsu API CreateServiceAsync . Jeśli usługa jest zadeklarowana jako usługa domyślna w manifeście aplikacji, usługa jest tworzone podczas tworzenia wystąpienia aplikacji. Wywołanie interfejsu API CreateServiceAsync dla usługi, która jest już utworzona, zwróci wyjątek typu FabricException. Wyjątek będzie zawierać kod błędu z wartością FabricErrorCode.ServiceAlreadyExists.

Usuwanie wystąpienia usługi

Gdy wystąpienie usługi nie jest już potrzebne, możesz usunąć je z uruchomionego wystąpienia aplikacji, wywołując interfejs API DeleteServiceAsync .

Ostrzeżenie

Nie można cofnąć tej operacji, a nie można odzyskać stanu usługi.

Usuwanie wystąpienia aplikacji

Gdy wystąpienie aplikacji nie jest już potrzebne, można je trwale usunąć przy użyciu interfejsu API DeleteApplicationAsync . DeleteApplicationAsync automatycznie usuwa wszystkie usługi należące do aplikacji, a także trwale usuwa cały stan usługi.

Ostrzeżenie

Nie można cofnąć tej operacji, a nie można odzyskać stanu aplikacji.

Wyrejestrowywanie typu aplikacji

Jeśli określona wersja typu aplikacji nie jest już potrzebna, należy wyrejestrować określoną wersję typu aplikacji przy użyciu interfejsu API Unregister-ServiceFabricApplicationType . Wyrejestrowywanie nieużywanych wersji typów aplikacji zwalnia miejsce do magazynowania używane przez magazyn obrazów. Wersja typu aplikacji może być wyrejestrowana tak długo, jak żadne aplikacje nie są tworzone dla tej wersji typu aplikacji. Ponadto typ aplikacji nie może mieć oczekujących uaktualnień aplikacji odwołujących się do tej wersji typu aplikacji.

Rozwiązywanie problemów

Copy-ServiceFabricApplicationPackage prosi o magazyn obrazów Połączenie ionString

Środowisko zestawu SDK usługi Service Fabric powinno już mieć skonfigurowane poprawne ustawienia domyślne. Jednak w razie potrzeby parametr ImageStore Połączenie ionString dla wszystkich poleceń powinien odpowiadać wartości używanej przez klaster usługi Service Fabric. Plik ImageStore Połączenie ionString można znaleźć w manifeście klastra pobranym przy użyciu poleceń Get-ServiceFabricClusterManifest i Get-ImageStore Połączenie ionStringFromClusterManifest:

PS C:\> Get-ImageStoreConnectionStringFromClusterManifest(Get-ServiceFabricClusterManifest)

Polecenie cmdlet Get-ImageStore Połączenie ionStringFromClusterManifest, które jest częścią modułu PowerShell zestawu SDK usługi Service Fabric, służy do pobierania magazynu obrazów parametry połączenia. Aby zaimportować moduł ZESTAWU SDK, uruchom polecenie:

Import-Module "$ENV:ProgramFiles\Microsoft SDKs\Service Fabric\Tools\PSModule\ServiceFabricSDK\ServiceFabricSDK.psm1"

Plik ImageStore Połączenie ionString znajduje się w manifeście klastra:

<ClusterManifest xmlns:xsd="https://www.w3.org/2001/XMLSchema" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" Name="Server-Default-SingleNode" Version="1.0" xmlns="http://schemas.microsoft.com/2011/01/fabric">

    [...]

    <Section Name="Management">
      <Parameter Name="ImageStoreConnectionString" Value="file:D:\ServiceFabric\Data\ImageStore" />
    </Section>

    [...]

Aby uzyskać dodatkowe informacje na temat magazynu obrazów i magazynu obrazów parametry połączenia, zobacz Omówienie magazynu obrazów parametry połączenia.

Wdrażanie dużego pakietu aplikacji

Problem: limit czasu interfejsu API CopyApplicationPackage dla dużego pakietu aplikacji (kolejność GB). Spróbuj:

  • Określ większy limit czasu dla metody CopyApplicationPackage z parametrem timeout . Domyślnie limit czasu wynosi 30 minut.
  • Sprawdź połączenie sieciowe między maszyną źródłową a klastrem. Jeśli połączenie działa wolno, rozważ użycie maszyny z lepszym połączeniem sieciowym. Jeśli maszyna kliencka znajduje się w innym regionie niż klaster, rozważ użycie maszyny klienckiej w bliżej lub tym samym regionie co klaster.
  • Sprawdź, czy występuje ograniczenie zewnętrzne. Na przykład gdy magazyn obrazów jest skonfigurowany do korzystania z usługi Azure Storage, przekazywanie może być ograniczone.

Problem: Przekazywanie pakietu zostało ukończone pomyślnie, ale upłynął limit czasu interfejsu API ProvisionApplicationAsync . Spróbuj:

  • Kompresuj pakiet przed skopiowaniem do magazynu obrazów. Kompresja zmniejsza rozmiar i liczbę plików, co z kolei zmniejsza ilość ruchu i pracy wymaganej przez usługę Service Fabric. Operacja przekazywania może być wolniejsza (zwłaszcza w przypadku uwzględnienia czasu kompresji), ale rejestrowanie i wyrejestrowywanie typu aplikacji jest szybsze.
  • Określ większy limit czasu dla interfejsu API ProvisionApplicationAsync z parametrem timeout .

Wdrażanie pakietu aplikacji z wieloma plikami

Problem: Limit czasu provisionApplicationAsync dla pakietu aplikacji z wieloma plikami (kolejność tysięcy). Spróbuj:

Przykład kodu

Poniższy przykład kopiuje pakiet aplikacji do magazynu obrazów i aprowizuje typ aplikacji. Następnie przykład tworzy wystąpienie aplikacji i tworzy wystąpienie usługi. Na koniec przykład usuwa wystąpienie aplikacji, anuluje aprowizacje typu aplikacji i usuwa pakiet aplikacji z magazynu obrazów.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Threading.Tasks;

using System.Fabric;
using System.Fabric.Description;
using System.Threading;

namespace ServiceFabricAppLifecycle
{
class Program
{
static void Main(string[] args)
{

    string clusterConnection = "localhost:19000";
    string appName = "fabric:/MyApplication";
    string appType = "MyApplicationType";
    string appVersion = "1.0.0";
    string serviceName = "fabric:/MyApplication/Stateless1";
    string imageStoreConnectionString = "file:C:\\SfDevCluster\\Data\\ImageStoreShare";
    string packagePathInImageStore = "MyApplication";
    string packagePath = "C:\\Users\\username\\Documents\\Visual Studio 2019\\Projects\\MyApplication\\MyApplication\\pkg\\Debug";
    string serviceType = "Stateless1Type";

    // Connect to the cluster.
    FabricClient fabricClient = new FabricClient(clusterConnection);

    // Copy the application package to a location in the image store
    try
    {
        fabricClient.ApplicationManager.CopyApplicationPackage(imageStoreConnectionString, packagePath, packagePathInImageStore);
        Console.WriteLine("Application package copied to {0}", packagePathInImageStore);
    }
    catch (AggregateException ae)
    {
        Console.WriteLine("Application package copy to Image Store failed: ");
        foreach (Exception ex in ae.InnerExceptions)
        {
            Console.WriteLine("HResult: {0} Message: {1}", ex.HResult, ex.Message);
        }
    }

    // Provision the application.  "MyApplicationV1" is the folder in the image store where the application package is located. 
    // The application type with name "MyApplicationType" and version "1.0.0" (both are found in the application manifest) 
    // is now registered in the cluster.            
    try
    {
        fabricClient.ApplicationManager.ProvisionApplicationAsync(packagePathInImageStore).Wait();

        Console.WriteLine("Provisioned application type {0}", packagePathInImageStore);
    }
    catch (AggregateException ae)
    {
        Console.WriteLine("Provision Application Type failed:");

        foreach (Exception ex in ae.InnerExceptions)
        {
            Console.WriteLine("HResult: {0} Message: {1}", ex.HResult, ex.Message);
        }
    }

    // Delete the application package from a location in the image store.
    try
    {
        fabricClient.ApplicationManager.RemoveApplicationPackage(imageStoreConnectionString, packagePathInImageStore);
        Console.WriteLine("Application package removed from {0}", packagePathInImageStore);
    }
    catch (AggregateException ae)
    {
        Console.WriteLine("Application package removal from Image Store failed: ");
        foreach (Exception ex in ae.InnerExceptions)
        {
            Console.WriteLine("HResult: {0} Message: {1}", ex.HResult, ex.Message);
        }
    }

    //  Create the application instance.
    try
    {
        ApplicationDescription appDesc = new ApplicationDescription(new Uri(appName), appType, appVersion);
        fabricClient.ApplicationManager.CreateApplicationAsync(appDesc).Wait();
        Console.WriteLine("Created application instance of type {0}, version {1}", appType, appVersion);
    }
    catch (AggregateException ae)
    {
        Console.WriteLine("CreateApplication failed.");
        foreach (Exception ex in ae.InnerExceptions)
        {
            Console.WriteLine("HResult: {0} Message: {1}", ex.HResult, ex.Message);
        }
    }

    // Create the stateless service description.  For stateful services, use a StatefulServiceDescription object.
    StatelessServiceDescription serviceDescription = new StatelessServiceDescription();
    serviceDescription.ApplicationName = new Uri(appName);
    serviceDescription.InstanceCount = 1;
    serviceDescription.PartitionSchemeDescription = new SingletonPartitionSchemeDescription();
    serviceDescription.ServiceName = new Uri(serviceName);
    serviceDescription.ServiceTypeName = serviceType;

    // Create the service instance.  If the service is declared as a default service in the ApplicationManifest.xml,
    // the service instance is already running and this call will fail.
    try
    {
        fabricClient.ServiceManager.CreateServiceAsync(serviceDescription).Wait();
        Console.WriteLine("Created service instance {0}", serviceName);
    }
    catch (AggregateException ae)
    {
        Console.WriteLine("CreateService failed.");
        foreach (Exception ex in ae.InnerExceptions)
        {
            Console.WriteLine("HResult: {0} Message: {1}", ex.HResult, ex.Message);
        }
    }

    // Delete a service instance.
    try
    {
        DeleteServiceDescription deleteServiceDescription = new DeleteServiceDescription(new Uri(serviceName));

        fabricClient.ServiceManager.DeleteServiceAsync(deleteServiceDescription);
        Console.WriteLine("Deleted service instance {0}", serviceName);
    }
    catch (AggregateException ae)
    {
        Console.WriteLine("DeleteService failed.");
        foreach (Exception ex in ae.InnerExceptions)
        {
            Console.WriteLine("HResult: {0} Message: {1}", ex.HResult, ex.Message);
        }
    }

    // Delete an application instance from the application type.
    try
    {
        DeleteApplicationDescription deleteApplicationDescription = new DeleteApplicationDescription(new Uri(appName));

        fabricClient.ApplicationManager.DeleteApplicationAsync(deleteApplicationDescription).Wait();
        Console.WriteLine("Deleted application instance {0}", appName);
    }
    catch (AggregateException ae)
    {
        Console.WriteLine("DeleteApplication failed.");
        foreach (Exception ex in ae.InnerExceptions)
        {
            Console.WriteLine("HResult: {0} Message: {1}", ex.HResult, ex.Message);
        }
    }

    // Un-provision the application type.
    try
    {
        fabricClient.ApplicationManager.UnprovisionApplicationAsync(appType, appVersion).Wait();
        Console.WriteLine("Un-provisioned application type {0}, version {1}", appType, appVersion);
    }
    catch (AggregateException ae)
    {
        Console.WriteLine("Un-provision application type failed: ");
        foreach (Exception ex in ae.InnerExceptions)
        {
            Console.WriteLine("HResult: {0} Message: {1}", ex.HResult, ex.Message);
        }
    }

    Console.WriteLine("Hit enter...");
    Console.Read();
}        
}
}

Następne kroki

Uaktualnianie aplikacji usługi Service Fabric

Wprowadzenie do kondycji usługi Service Fabric

Diagnozowanie i rozwiązywanie problemów z usługą Service Fabric

Modelowanie aplikacji w usłudze Service Fabric