Sdílet prostřednictvím

Nasazení a odebrání aplikací pomocí FabricClient

  • Článek

Jakmile je typ aplikace zabalený, je připravený k nasazení do clusteru Azure Service Fabric. Nasazení zahrnuje následující tři kroky:

  1. Nahrání balíčku aplikace do úložiště imagí
  2. Registrace typu aplikace
  3. Odebrání balíčku aplikace z úložiště imagí
  4. Vytvoření instance aplikace

Po nasazení aplikace a spuštění instance v clusteru můžete instanci aplikace a její typ aplikace odstranit. Zcela odeberte aplikaci z clusteru pomocí následujícího postupu:

  1. Odebrání (nebo odstranění) spuštěné instance aplikace
  2. Zrušení registrace typu aplikace, pokud ho už nepotřebujete

Pokud k nasazování a ladění aplikací v místním vývojovém clusteru používáte Visual Studio, všechny předchozí kroky se automaticky zpracovávají pomocí skriptu PowerShellu. Tento skript se nachází ve složce Scripts projektu aplikace. Tento článek obsahuje základní informace o tom, co tento skript dělá, abyste mohli provádět stejné operace mimo Visual Studio.

Připojení ke clusteru

Před spuštěním některého z příkladů kódu v tomto článku se připojte ke clusteru vytvořením instance FabricClient . Příklady připojení k místnímu vývojovému clusteru nebo vzdálenému clusteru nebo clusteru zabezpečenému pomocí Microsoft Entra ID, certifikátů X509 nebo Služby Windows Active Directory naleznete v tématu Připojení k zabezpečenému clusteru. Pokud se chcete připojit k místnímu vývojovému clusteru, spusťte následující příklad:

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

Nahrání balíčku aplikace

Předpokládejme, že sestavíte a zabalíte aplikaci s názvem MyApplication v sadě Visual Studio. Ve výchozím nastavení je název typu aplikace uvedený v ApplicationManifest.xml "MyApplicationType". Balíček aplikace, který obsahuje nezbytný manifest aplikace, manifesty služby a balíčky kódu/config/data, se nachází v umístění C:\Users< username>\Documents\Visual Studio 2019\Projects\MyApplication\MyApplication\pkg\Debug.

Nahrání balíčku aplikace ho umístí do umístění, které je přístupné interními komponentami Service Fabric. Service Fabric ověří balíček aplikace během registrace balíčku aplikace. Pokud ale chcete balíček aplikace ověřit místně (tj. před nahráním), použijte rutinu Test-ServiceFabricApplicationPackage .

Rozhraní API CopyApplicationPackage nahraje balíček aplikace do úložiště imagí clusteru.

Pokud je balíček aplikace velký nebo obsahuje mnoho souborů, můžete ho zkomprimovat a zkopírovat do úložiště imagí pomocí PowerShellu. Komprese zmenšuje velikost a počet souborů.

Další informace o úložišti imagí a úložišti imagí připojovací řetězec najdete v tématu Vysvětlení připojovací řetězec úložiště imagí.

Registrace balíčku aplikace

Typ a verze aplikace deklarované v manifestu aplikace budou k dispozici pro použití při registraci balíčku aplikace. Systém přečte balíček nahraný v předchozím kroku, ověří balíček, zpracuje obsah balíčku a zkopíruje zpracovaný balíček do interního systémového umístění.

Rozhraní ProvisionApplicationAsync API zaregistruje typ aplikace v clusteru a zpřístupní ho pro nasazení.

Rozhraní Api GetApplicationTypeListAsync poskytuje informace o všech úspěšně registrovaných typech aplikací. Toto rozhraní API můžete použít k určení, kdy se registrace dokončí.

Odebrání balíčku aplikace z úložiště imagí

Po úspěšné registraci aplikace doporučujeme odebrat balíček aplikace. Odstranění balíčků aplikací z úložiště imagí uvolní systémové prostředky. Udržování nepoužívaných balíčků aplikací spotřebovává diskové úložiště a vede k problémům s výkonem aplikací. Pomocí rozhraní API RemoveApplicationPackage odstraňte balíček aplikace z úložiště imagí.

Vytvoření instance aplikace

Pomocí rozhraní CreateApplicationAsync API můžete vytvořit instanci aplikace z libovolného typu aplikace, který byl úspěšně zaregistrován. Název každé aplikace musí začínat schématem "fabric:" a musí být jedinečný pro každou instanci aplikace (v rámci clusteru). Vytvoří se také všechny výchozí služby definované v manifestu aplikace cílového typu aplikace.

Pro libovolnou verzi registrované aplikace je možné vytvořit více instancí aplikace. Každá instance aplikace běží izolovaně s vlastním pracovním adresářem a sadou procesů.

Pokud chcete zjistit, které pojmenované aplikace a služby běží v clusteru, spusťte rozhraní API GetApplicationListAsync a GetServiceListAsync .

Vytvoření instance služby

Pomocí rozhraní CREATEServiceAsync API můžete vytvořit instanci služby z typu služby. Pokud je služba v manifestu aplikace deklarována jako výchozí služba, vytvoří se instance služby při vytvoření instance aplikace. Volání rozhraní CreateServiceAsync API pro službu, která je již vytvořena instance, vrátí výjimku typu FabricException. Výjimka bude obsahovat kód chyby s hodnotou FabricErrorCode.ServiceAlreadyExists.

Odebrání instance služby

Pokud už instance služby není potřebná, můžete ji odebrat ze spuštěné instance aplikace voláním rozhraní DELETEServiceAsync API.

Upozorňující

Tuto operaci nelze vrátit zpět a stav služby nelze obnovit.

Odebrání instance aplikace

Pokud už instanci aplikace nepotřebujete, můžete ji trvale odebrat pomocí názvu pomocí rozhraní DELETEApplicationAsync API. DeleteApplicationAsync automaticky odebere všechny služby, které patří do aplikace, a trvale odebere veškerý stav služby.

Upozorňující

Tuto operaci nelze vrátit zpět a stav aplikace nelze obnovit.

Zrušení registrace typu aplikace

Pokud už konkrétní verzi typu aplikace nepotřebujete, měli byste zrušit registraci konkrétní verze typu aplikace pomocí rozhraní API Unregister-ServiceFabricApplicationType . Zrušení registrace nepoužívaných verzí typů aplikací uvolní místo úložiště používané úložištěm imagí. Verze typu aplikace může být zrušena, pokud se pro danou verzi typu aplikace nedají vytvořit instance žádné aplikace. Typ aplikace navíc nemůže mít žádné nevyřízené upgrady aplikací odkazující na tuto verzi typu aplikace.

Řešení problému

Copy-ServiceFabricApplicationPackage žádá o imageStoreConnectionString

Prostředí sady Service Fabric SDK by už mělo mít nastavené správné výchozí hodnoty. V případě potřeby by ale imageStoreConnectionString pro všechny příkazy měl odpovídat hodnotě, kterou cluster Service Fabric používá. ImageStoreConnectionString najdete v manifestu clusteru, který se načte pomocí příkazů Get-ServiceFabricClusterManifest a Get-ImageStoreConnectionStringFromClusterManifest:

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

Rutina Get-ImageStoreConnectionStringFromClusterManifest, která je součástí modulu PowerShell sady Service Fabric SDK, slouží k získání úložiště imagí připojovací řetězec. Pokud chcete importovat modul SDK, spusťte:

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

ImageStoreConnectionString se nachází v manifestu clusteru:

<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>

    [...]

Další informace o úložišti imagí a úložišti imagí připojovací řetězec najdete v tématu Vysvětlení připojovací řetězec úložiště imagí.

Nasazení velkého balíčku aplikace

Problém: U velkého balíčku aplikace (pořadí GB) vyprší časový limit rozhraní API CopyApplicationPackage . Vyzkoušejte:

  • Zadejte větší časový limit metody CopyApplicationPackage s parametrem timeout . Ve výchozím nastavení je časový limit 30 minut.
  • Zkontrolujte síťové připojení mezi zdrojovým počítačem a clusterem. Pokud je připojení pomalé, zvažte použití počítače s lepším síťovým připojením. Pokud je klientský počítač v jiné oblasti než cluster, zvažte použití klientského počítače v bližší nebo stejné oblasti jako cluster.
  • Zkontrolujte, jestli nesáhnete na externí omezování. Pokud je například úložiště imagí nakonfigurované tak, aby používalo úložiště Azure, může dojít k omezení nahrávání.

Problém: Nahrávání balíčku se úspěšně dokončilo, ale vypršel časový limit rozhraní API ProvisionApplicationAsync . Zkusit:

Nasazení balíčku aplikace s mnoha soubory

Problém: Vypršel časový limit zřizováníApplicationAsync pro balíček aplikace s mnoha soubory (pořadí tisíců). Vyzkoušejte:

Příklad kódu

Následující příklad zkopíruje balíček aplikace do úložiště imagí a zřídí typ aplikace. Pak příklad vytvoří instanci aplikace a vytvoří instanci služby. Nakonec příklad odebere instanci aplikace, zruší zřízení typu aplikace a odstraní balíček aplikace z úložiště imagí.

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();
}        
}
}

Další kroky

Upgrade aplikace Service Fabric

Úvod ke stavu Service Fabric

Diagnostika a řešení potíží se službou Service Fabric

Modelování aplikace v Service Fabric