Partager via

Migrer des services cloud Azure vers Service Fabric

Ce guide fournit des étapes détaillées et des bonnes pratiques pour la migration d’applications d’Azure Cloud Services vers Azure Service Fabric. Tout au long de ce guide, nous vous recommandons d’utiliser des clusters managés Service Fabric , car ils fournissent une gestion simplifiée des clusters, une sécurité renforcée et des mises à jour correctives automatisées.

Vous devez passer en revue la matrice de décision pour la migration à partir des services cloud pour vous assurer que vous choisissez les services Azure appropriés à partir de votre architecture.

Évaluation de la prémigration

Avant de migrer des services cloud Azure vers Service Fabric, effectuez une évaluation approfondie :

Inventaire des applications

  • Documenter tous les rôles Web et Worker
  • Identifier les dépendances et les points d’intégration
  • Mapper les exigences de stockage (disque local, Stockage Azure, etc.)
  • Configuration requise pour la mise à l’échelle des documents

Modèles de trafic et exigences de mise à l’échelle

  • Analyser les modèles de trafic actuels
  • Déclencheurs et règles de mise à l’échelle des documents
  • Évaluer les exigences de mise à l’échelle automatique

Gestion de l'état

  • Identifier les composants avec état
  • Mécanismes de persistance des données de document
  • Évaluer les dépendances du cache

Identifier les contraintes d’application

  • Dépendances de démarrage
  • Modèles de communication de rôle
  • Conditions requises pour le déploiement
  • Contraintes d’authentification et de sécurité

Évaluation de la préparation de la production

Passez en revue la liste de contrôle de préparation de la production Service Fabric pour vous assurer que votre future application Service Fabric répond aux normes de production.

Planification de l’architecture

Cluster managé Service Fabric et cluster classique

Service Fabric propose deux modèles de déploiement :

  • Clusters managés Service Fabric (recommandé) : modèle de ressource de cluster simplifié où Microsoft gère l’infrastructure de cluster sous-jacente.

  • Clusters Service Fabric traditionnels : personnalisables mais nécessitant une gestion plus opérationnelle.

Nous vous recommandons vivement d’utiliser des clusters managés Service Fabric pour les migrations à partir de Services cloud afin de simplifier les opérations et de garantir une meilleure posture de sécurité.

Modèles d’architecture Service Fabric

Mappez vos composants Cloud Services aux modèles architecturaux Service Fabric :

Composant de services cloud Équivalent Service Fabric
Rôle web Service sans état avec ASP.NET Core
Instances de Service sans état avec traitement en arrière-plan
Instances de rôle Instances de service et partitions
Environnement de rôle Contexte d’application Service Fabric
Stockage local Volumes de stockage locaux Service Fabric
RoleEntryPoint Méthode ServiceInstanceListener ou RunAsync

Structure de cluster Service Fabric pour les clusters managés

Pour configurer un cluster managé Service Fabric, reportez-vous aux modèles ARM officiels disponibles dans le référentiel modèles de démarrage rapide Azure.

Un modèle ARM de cluster managé de base ressemble à ceci (comme indiqué dans la documentation officielle) :

{
  "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "clusterName": {
      "type": "string",
      "defaultValue": "GEN-UNIQUE",
      "metadata": {
        "description": "Name of your cluster - Between 3 and 23 characters. Letters and numbers only."
      }
    },
    "adminUsername": {
      "type": "string",
      "metadata": {
        "description": "Remote desktop user Id"
      }
    },
    "adminPassword": {
      "type": "securestring",
      "metadata": {
        "description": "Remote desktop user password. Must be a strong password"
      }
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]",
      "metadata": {
        "description": "Location of the Cluster"
      }
    }
  },
  "variables": {
    "sfManagedClusterName": "[parameters('clusterName')]",
    "managedNodeType": "NT1"
  },
  "resources": [
    {
      "apiVersion": "2021-11-01-preview",
      "type": "Microsoft.ServiceFabric/managedClusters",
      "name": "[variables('sfManagedClusterName')]",
      "location": "[parameters('location')]",
      "sku": {
        "name": "Basic"
      },
      "properties": {
        "dnsName": "[variables('sfManagedClusterName')]",
        "adminUserName": "[parameters('adminUsername')]",
        "adminPassword": "[parameters('adminPassword')]"
      }
    },
    {
      "apiVersion": "2021-11-01-preview",
      "type": "Microsoft.ServiceFabric/managedClusters/nodeTypes",
      "name": "[concat(variables('sfManagedClusterName'), '/', variables('managedNodeType'))]",
      "location": "[parameters('location')]",
      "dependsOn": [
        "[concat('Microsoft.ServiceFabric/managedClusters/', variables('sfManagedClusterName'))]"
      ],
      "sku": {
        "name": "Standard",
        "tier": "Standard"
      },
      "properties": {
        "isPrimary": true,
        "vmInstanceCount": 5,
        "dataDiskSizeGB": 100,
        "vmSize": "Standard_D2s_v3"
      }
    }
  ]
}

Pour obtenir des instructions d’installation détaillées, consultez Démarrage rapide : Déployer un cluster managé Service Fabric à l’aide de modèles ARM.

Considérations relatives à la sécurité

Les clusters managés Service Fabric gèrent automatiquement la plupart des configurations de sécurité, notamment :

  • Rotation automatique des certificats de cluster
  • Communication sécurisée par défaut de nœud à nœud
  • Chiffrement des données de configuration de cluster
  • Règles de sécurité réseau intégrées

Pour l’authentification du client auprès des clusters, vous devez configurer des certificats clients :

  • Certificats clients : pour accéder au cluster et à Service Fabric Explorer

    • Utiliser des certificats auto-signés (pour le développement/test) ou
    • Certificats émis par l’autorité de certification (recommandés pour la production)
    • Ajouter des certificats clients à votre configuration de cluster managé

  • Sécurité des applications : implémenter des recommandations de sécurité des applications et des services

  • Sécurité réseau : configurer des groupes de sécurité réseau et des pare-feu en fonction des meilleures pratiques service Fabric pour la sécurité

Avec les clusters managés, vous pouvez vous concentrer principalement sur la sécurité au niveau de l’application et l’accès contrôlé à votre cluster, tandis que Microsoft gère l’infrastructure de sécurité de cluster sous-jacente.

Stratégie de migration

Choisir une approche de migration

Migration lift-and-shift

Modifications minimales apportées à l’architecture d’application, en mettant l’accent sur l’adaptation du code existant à exécuter dans Service Fabric.

Avantages :

  • Chronologie de migration plus rapide
  • Réduire l’effort de développement initial
  • Réduction du risque de modifications fonctionnelles

Inconvénients :

  • Ne tire pas pleinement parti des fonctionnalités Service Fabric
  • Peut nécessiter une refactorisation future pour optimiser

Limitation importante : les clusters managés Service Fabric ne prennent actuellement pas en charge les conteneurs. Si votre application requiert iis, des composants serveur spécifiques à Windows ou d’autres dépendances qui seraient mieux conteneurisées, vous devez utiliser un cluster Service Fabric traditionnel avec prise en charge du conteneur Windows au lieu d’un cluster géré. Prenez soigneusement en considération cette limitation lors de la planification de votre approche de migration lift-and-shift. Reportez-vous à Conteneuriser les applications Windows existantes

Refactoriser vers les microservices

Décomposez l’application en microservices pour une plus grande scalabilité et une maintenance plus facile.

Avantages :

  • Utilisation complète des fonctionnalités de Service Fabric
  • Amélioration de la scalabilité et de la résilience
  • Meilleure séparation des préoccupations

Inconvénients :

  • Effort de développement initial plus élevé
  • Nécessite une expertise architecturale
  • Chronologie de migration plus longue

Approches de migration basées sur les exigences d’application

Quand utiliser des clusters managés :

  • Applications basées sur .NET qui peuvent être migrées directement vers les services Service Fabric
  • ASP.NET applications web principales qui peuvent s’exécuter sans IIS
  • Applications avec dépendances légères
  • Nouvelles applications écrites spécifiquement pour Service Fabric

Quand utiliser des clusters Service Fabric classiques :

  • Applications nécessitant des conteneurs Windows
  • Charges de travail avec dépendances IIS (devraient être conteneurisées)
  • Applications avec dépendances de composant serveur complexes
  • Scénarios nécessitant une conteneurisation

Phases de migration

  1. Configurer l’environnement Service Fabric

  2. Migrer la configuration et les paramètres

    • Mapper la configuration du service cloud (.cscfg, .csdef) aux manifestes d’application Service Fabric
    • Migrer les paramètres d’environnement vers les paramètres Service Fabric

  3. Migrer le code

    • Adapter des rôles web à des services sans état ou à des applications conteneurisées
    • Adapter des rôles de travail à des services sans état ou des services fiables
    • Migrer des tâches de démarrage vers le code d’installation de Service Fabric

  4. Migrer la gestion de l’état

    • Implémenter des solutions de gestion d’état appropriées (Collections Fiables)
    • Migrer l’état persistant à partir de magasins externes

  5. Implémenter la communication de service

    • Remplacer la communication de rôle par des modèles de communication Service Fabric
    • Configurer la découverte de services

  6. Tester et optimiser

    • Valider les fonctionnalités et les performances
    • Tester la mise à l’échelle et les scénarios de basculement
    • Optimiser l’utilisation des ressources

Processus de migration pas à pas

1. Configurer un cluster managé Service Fabric

Pour déployer un cluster managé Service Fabric, vous pouvez utiliser des commandes PowerShell comme indiqué dans le tutoriel : Déployer un cluster managé Service Fabric.

Utilisation de PowerShell :

# Connect to your Azure account
Login-AzAccount
Set-AzContext -SubscriptionId <your-subscription>

# Create a new resource group
$resourceGroup = "myResourceGroup"
$location = "EastUS2"
New-AzResourceGroup -Name $resourceGroup -Location $location

# Create a Service Fabric managed cluster
$clusterName = "<unique cluster name>"
$password = "Password4321!@#" | ConvertTo-SecureString -AsPlainText -Force
$clientThumbprint = "<certificate thumbprint>"  # Client certificate for authentication
$clusterSku = "Standard"

New-AzServiceFabricManagedCluster -ResourceGroupName $resourceGroup -Location $location -ClusterName $clusterName -ClientCertThumbprint $clientThumbprint -ClientCertIsAdmin -AdminPassword $password -Sku $clusterSKU -Verbose

# Add a primary node type to the cluster
$nodeType1Name = "NT1"
New-AzServiceFabricManagedNodeType -ResourceGroupName $resourceGroup -ClusterName $clusterName -Name $nodeType1Name -Primary -InstanceCount 5

Remarques importantes :

  • Pour les déploiements de production, utilisez la référence SKU Standard (référence SKU de base uniquement pour les tests)
  • Vous devez fournir une empreinte numérique de certificat client pour accéder au cluster
  • Chaque cluster Service Fabric nécessite un type de nœud principal et peut avoir un ou plusieurs types de nœuds secondaires
  • Visualiser votre cluster avec Service Fabric Explorer

Vous pouvez également utiliser le portail Azure ou Azure CLI pour le déploiement. Pour une configuration basée sur le portail, suivez le guide de démarrage rapide : Créer un didacticiel sur un cluster managé Service Fabric .

2. Créer des projets d’application Service Fabric

Utilisez Visual Studio pour créer des applications Service Fabric :

Utilisez Visual Studio :

  1. Préparer votre environnement de développement sur Windows
  2. Créer un service sans état – Projet Service Fabric
  3. Créez un service avec état – Projet Service Fabric :

3. Migration de rôles web de service cloud - Exemple complet

  1. Créer un service sans état avec ASP.NET Core
  2. Migrer des contrôleurs et des vues
  3. Configurer des points de terminaison de service
// Service registration in Program.cs
internal sealed class Program
{
    private static void Main()
    {
        try
        {
            ServiceRuntime.RegisterServiceAsync("WebFrontEndType", 
                context => new WebFrontEnd(context)).GetAwaiter().GetResult();

            ServiceEventSource.Current.ServiceTypeRegistered(
                Process.GetCurrentProcess().Id, typeof(WebFrontEnd).Name);

            Thread.Sleep(Timeout.Infinite);
        }
        catch (Exception e)
        {
            ServiceEventSource.Current.ServiceHostInitializationFailed(e.ToString());
            throw;
        }
    }
}

// Service implementation
internal sealed class WebFrontEnd : StatelessService
{
    public WebFrontEnd(StatelessServiceContext context)
        : base(context)
    { }

    protected override IEnumerable<ServiceInstanceListener> CreateServiceInstanceListeners()
    {
        return new ServiceInstanceListener[]
        {
            new ServiceInstanceListener(serviceContext =>
                new KestrelCommunicationListener(serviceContext, "ServiceEndpoint", (url, listener) =>
                {
                    var builder = WebApplication.CreateBuilder();

                    builder.Services.AddSingleton<StatelessServiceContext>(serviceContext);
                    
                    // Add services to the container
                    builder.Services.AddControllers();
                    builder.Services.AddRazorPages();
                    
                    var app = builder.Build();
                    
                    // Configure middleware
                    if (app.Environment.IsDevelopment())
                    {
                        app.UseDeveloperExceptionPage();
                    }
                    else
                    {
                        app.UseExceptionHandler("/Error");
                        app.UseHsts();
                    }
                    
                    app.UseStaticFiles();
                    app.UseRouting();
                    app.UseAuthorization();
                    
                    app.MapControllers();
                    app.MapRazorPages();
                    
                    return app;
                }))
        };
    }
}

4. Migrer des rôles de travail de service cloud - Exemple complet

  1. Créer un service sans état avec traitement en arrière-plan
  2. Déplacer la logique de travail vers la méthode RunAsync
  3. Implémenter des événements de service et des minuteurs
internal sealed class WorkerBackgroundService : StatelessService
{
    private readonly TimeSpan _interval = TimeSpan.FromSeconds(30);
    
    public WorkerBackgroundService(StatelessServiceContext context)
        : base(context)
    { }

    protected override async Task RunAsync(CancellationToken cancellationToken)
    {
        while (!cancellationToken.IsCancellationRequested)
        {
            try
            {
                // Migrated worker role processing logic
                await ProcessQueueMessagesAsync(cancellationToken);
                await Task.Delay(_interval, cancellationToken);
            }
            catch (Exception ex)
            {
                ServiceEventSource.Current.ServiceMessage(Context, $"Exception in RunAsync: {ex.Message}");
                // Implement appropriate retry logic
            }
        }
    }

    private async Task ProcessQueueMessagesAsync(CancellationToken cancellationToken)
    {
        // Implement your worker logic here
    }
}

5. Migration de la configuration

Service Fabric utilise un modèle de configuration hiérarchique :

  1. ApplicationManifest.xml: configuration à l’échelle de l’application
<ApplicationManifest ApplicationTypeName="MyApplicationType"
                     ApplicationTypeVersion="1.0.0"
                     xmlns="http://schemas.microsoft.com/2011/01/fabric"
                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <Parameters>
    <Parameter Name="WebFrontEnd_InstanceCount" DefaultValue="-1" />
    <Parameter Name="StorageAccountConnectionString" DefaultValue="" />
    <Parameter Name="ASPNETCORE_ENVIRONMENT" DefaultValue="Production" />
  </Parameters>
  
  <ServiceManifestImport>
    <ServiceManifestRef ServiceManifestName="WebFrontEndPkg" ServiceManifestVersion="1.0.0" />
    <ConfigOverrides>
      <ConfigOverride Name="Config">
        <Settings>
          <Section Name="ConnectionStrings">
            <Parameter Name="StorageAccount" Value="[StorageAccountConnectionString]" />
          </Section>
          <Section Name="Environment">
            <Parameter Name="ASPNETCORE_ENVIRONMENT" Value="[ASPNETCORE_ENVIRONMENT]" />
          </Section>
        </Settings>
      </ConfigOverride>
    </ConfigOverrides>
  </ServiceManifestImport>
</ApplicationManifest>
  1. ServiceManifest.xml: configuration spécifique au service
<ServiceManifest Name="WebFrontEndPkg"
                 Version="1.0.0"
                 xmlns="http://schemas.microsoft.com/2011/01/fabric"
                 xmlns:xsd="http://www.w3.org/2001/XMLSchema"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <ConfigPackage Name="Config" Version="1.0.0" />
  <CodePackage Name="Code" Version="1.0.0">
    <EntryPoint>
      <ExeHost>
        <Program>WebFrontEnd.exe</Program>
        <WorkingFolder>CodeBase</WorkingFolder>
      </ExeHost>
    </EntryPoint>
  </CodePackage>
  <Resources>
    <Endpoints>
      <Endpoint Name="ServiceEndpoint" Protocol="http" Port="8080" />
    </Endpoints>
  </Resources>
</ServiceManifest>
  1. Settings.xml: paramètres de configuration
<?xml version="1.0" encoding="utf-8" ?>
<Settings xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.microsoft.com/2011/01/fabric">
  <Section Name="ConnectionStrings">
    <Parameter Name="StorageAccount" Value="" />
  </Section>
  <Section Name="Environment">
    <Parameter Name="ASPNETCORE_ENVIRONMENT" Value="Production" />
  </Section>
</Settings>

6. Configuration d’accès dans Service Fabric

// Accessing configuration in a Service Fabric service
public sealed class WebFrontEnd : StatelessService
{
    private readonly IConfiguration _configuration;
    
    public WebFrontEnd(StatelessServiceContext context)
        : base(context)
    {
        // Load Service Fabric configuration
        var configPackagePath = context.CodePackageActivationContext.GetConfigurationPackageObject("Config").Path;
        
        _configuration = new ConfigurationBuilder()
            .SetBasePath(configPackagePath)
            .AddJsonFile("appsettings.json", optional: true)
            .AddXmlFile("Settings.xml")
            .AddEnvironmentVariables()
            .Build();
    }
    
    protected override IEnumerable<ServiceInstanceListener> CreateServiceInstanceListeners()
    {
        // Create service listeners using configuration
        var connectionString = _configuration.GetSection("ConnectionStrings")["StorageAccount"];
        // Use connection string to configure services
    }
}

7. Déployer sur un cluster managé Service Fabric

  1. Empaqueter l’application Service Fabric :
# Package the Service Fabric application
$appPkgPath = "C:\MyServiceFabricApp\pkg"
Copy-ServiceFabricApplicationPackage -ApplicationPackagePath $appPkgPath -CompressPackage -SkipCopy
  1. Déployer sur un cluster managé :
# Connect to the cluster
Connect-ServiceFabricCluster -ConnectionEndpoint "mycluster.westus.cloudapp.azure.com:19000"

# Register and create the application
Register-ServiceFabricApplicationType -ApplicationPackagePathInImageStore MyServiceFabricApp
New-ServiceFabricApplication -ApplicationName fabric:/MyServiceFabricApp -ApplicationTypeName MyServiceFabricAppType -ApplicationTypeVersion 1.0.0

Vous pouvez également utiliser Azure Pipelines pour les déploiements automatisés sur des clusters managés Service Fabric.

Tests et validation

Test fonctionnel

  • Valider toutes les fonctionnalités d’application
  • Tester la découverte et la communication des services
  • Vérifier que la configuration est correctement chargée
  • Valider l’expérience utilisateur et les flux

Tests des performances

  • Comparer les temps de réponse avec les services cloud
  • Test sous charge utilisateur attendue
  • Valider les paramètres de mise à l’échelle automatique
  • Mesurer l’utilisation des ressources

Tests de résilience

  • Scénarios de test de basculement
  • Valider le comportement de recyclage des instances
  • Tester les processus de mise à niveau et de restauration
  • Simuler des défaillances d’infrastructure

Liste de vérification de validation

  • [ ] Toutes les fonctions fonctionnent correctement
  • [ ] Les performances répondent ou dépassent les services cloud
  • [ ] La migration de configuration est terminée
  • [ ] Travail de journalisation et de diagnostic
  • [ ] Les exigences de sécurité sont remplies
  • [ ] Le pipeline de déploiement est établi
  • [ ] La surveillance et les alertes sont configurées
  • [ ] Les procédures de restauration sont documentées

Considérations relatives à la post-migration

Surveillance et diagnostics

Avertissement

Application Insights pour le Kit de développement logiciel (SDK) Service Fabric n’est plus pris en charge.

Visualiser votre cluster avec Service Fabric Explorer

Configurez la supervision et les diagnostics Service Fabric pour votre application :

  • Activer Application Insights
  • Configurer la collecte des diagnostics de Service Fabric
  • Configurer des alertes et des tableaux de bord
  • Mise en œuvre de la création de rapports d’intégrité
// Adding health reporting in your service
var healthClient = new FabricClient().HealthManager;
var healthReport = new HealthReport(
    serviceName: new Uri("fabric:/MyApp/MyService"),
    sourceId: "MyHealthWatcher",
    healthProperty: "Connectivity",
    healthState: HealthState.Ok,
    description: "Service is connected to dependencies"
);
await healthClient.ReportHealthAsync(healthReport);

Mise à l’échelle et optimisation

Les clusters managés Service Fabric prennent en charge la mise à l’échelle manuelle et la mise à l’échelle automatique :

{
  "apiVersion": "2021-05-01",
  "type": "Microsoft.ServiceFabric/managedClusters/nodeTypes",
  "name": "[concat(parameters('clusterName'), '/FrontEnd')]",
  "location": "[parameters('location')]",
  "properties": {
    "vmInstanceCount": 5,
    "primaryCount": 5,
    "dataDiskSizeGB": 100,
    "vmSize": "Standard_D2s_v3"
  }
}

Planification de la récupération d’urgence

Posture de sécurité

Suivez les bonnes pratiques de sécurité :

  • Appliquer les meilleures pratiques de sécurité Service Fabric
  • Mettre régulièrement à jour les certificats clients
  • Passer en revue la sécurité réseau
  • Implémenter l’authentification et l’autorisation appropriées dans les applications

Guide de résolution des problèmes

Problèmes de déploiement

  • Vérifier que le manifeste de l’application est correct
  • Vérifier l’intégrité et la capacité du cluster
  • Valider les versions du package de service
  • Passer en revue les journaux de déploiement

Erreurs d’exécution

  • Vérifier les journaux de service
  • Vérifier les paramètres de configuration
  • Valider la communication de service
  • Passer en revue les événements de santé

Problèmes de performance

  • Analyser l’utilisation des ressources
  • Vérifier la charge de partition
  • Valider les stratégies de mise à l’échelle
  • Passer en revue le code de service pour les goulots d’étranglement

Scénarios et résolutions d’erreurs courants

Erreur Cause possible Résolution
Échec de l’activation du service Dépendances ou configuration manquantes Vérifier que toutes les dépendances et toutes les valeurs de configuration sont incluses dans le package de service
Échecs de communication Problèmes de réseau/pare-feu Vérifier les règles/sondes LoadBalancer, les règles de groupe de sécurité réseau et les points de terminaison de service
Erreurs de configuration Incompatibilités de paramètre Valider les paramètres de configuration sur toutes les couches
Problèmes de mise à l’échelle Capacité de cluster Passer en revue l’utilisation des ressources de nœud et augmenter la capacité si nécessaire

Scénarios de migration courants

Migration de rôles web

Pour obtenir un guide détaillé et complet sur la migration des rôles Web ASP.NET vers des services sans état de Service Fabric, consultez l’exemple de migration des rôles Web. Ce guide fournit des comparaisons de code détaillées entre les rôles Web d’origine et les implémentations Service Fabric, couvrant la structure du projet, les fichiers de configuration, la migration de middleware et les stratégies de déploiement avec des exemples de code côte à côte.

Migration des rôles de travail

Pour obtenir un guide détaillé sur la transformation du traitement en arrière-plan du rôle de travail vers Service Fabric, consultez l’exemple de migration de rôle de travail. Ce guide illustre la transition architecturale du traitement en arrière-plan des services cloud à l’exécution fiable des tâches dans Service Fabric, notamment les implémentations pour les minuteurs fiables, le traitement de file d’attente et la persistance de l’état avec des exemples de code pratiques.

Migration de la gestion de l’état

Pour obtenir des instructions détaillées sur la migration de la gestion de l’état des applications vers Service Fabric, consultez l’exemple de migration de gestion d’état d’état. Ce guide technique traite de la transition vers Des collections fiables avec des modèles d’implémentation pour la gestion des sessions, le traitement des flux de travail et la mise en cache, ainsi que les stratégies de migration de données, les procédures de sauvegarde/restauration et les approches hybrides combinant la gestion de l’état Service Fabric avec des magasins externes.

Ressources supplémentaires

  • Last updated on