Migrera en Azure IoT-hubb manuellt med hjälp av en Azure Resource Manager-mall

Artikel
04/16/2023

Använd Azure Portal, Azure Resource Manager-mallar och SDK:er för Azure IoT Hub-tjänsten för att migrera en IoT-hubb till en ny region, en ny nivå eller en ny konfiguration.

Stegen i den här artikeln är användbara om du vill:

Uppgradera från den kostnadsfria nivån till en IoT-hubb på basic- eller standardnivå.
Flytta en IoT-hubb till en ny region.
Exportera tillståndsinformation för IoT Hub som ska ha som en säkerhetskopia.
Öka antalet partitioner för en IoT-hubb.
Konfigurera en hubb för en utvecklingsmiljö i stället för en produktionsmiljö.
Aktivera en anpassad implementering av hög tillgänglighet för flera hubbar. Mer information finns i avsnittet How to achieve cross region HA (Så här uppnår du ha flera regioner) i IoT Hub hög tillgänglighet och haveriberedskap.

Om du vill migrera en hubb behöver du en prenumeration med administrativ åtkomst till den ursprungliga hubben. Du kan placera den nya hubben i en ny resursgrupp och region, i samma prenumeration som den ursprungliga hubben eller till och med i en ny prenumeration. Du kan bara inte använda samma namn eftersom hubbnamnet måste vara globalt unikt.

Jämföra automatiska och manuella migreringssteg

Resultatet av den här artikeln liknar hur du automatiskt migrerar en IoT-hubb med hjälp av Azure CLI, men med en annan process. Innan du börjar ska du bestämma vilken process som passar ditt scenario.

Den manuella processen (den här artikeln):
- Migrerar enhetsregistret och din routnings- och slutpunktsinformation. Du måste återskapa annan konfigurationsinformation manuellt i den nya IoT-hubben.
- Går snabbare att migrera ett stort antal enheter (till exempel mer än 100 000).
- Använder ett Azure Storage-konto för att överföra enhetsregistret.
- Rensar anslutningssträngar för routning och filuppladdningsslutpunkter från ARM-mallens utdata, och du måste lägga till dem igen manuellt.
Azure CLI-processen:
- Migrerar ditt enhetsregister, din routnings- och slutpunktsinformation och annan konfigurationsinformation som IoT Edge distributioner eller konfigurationer för automatisk enhetshantering.
- Är enklare att migrera ett litet antal enheter (till exempel upp till 10 000).
- Kräver inget Azure Storage-konto.
- Samlar in anslutningssträngar för routning och filuppladdningsslutpunkter och inkluderar dem i ARM-mallens utdata.

Saker att tänka på

Det finns flera saker att tänka på innan du migrerar en IoT-hubb.

Kontrollera att alla funktioner som är tillgängliga på den ursprungliga platsen också är tillgängliga på den nya platsen. Vissa tjänster är i förhandsversion och alla funktioner är inte tillgängliga överallt.
Ta inte bort de ursprungliga resurserna innan du skapar och verifierar den migrerade versionen. När du har tagit bort en hubb är den borta för alltid och det går inte att återställa den för att kontrollera inställningarna eller data för att se till att hubben replikeras korrekt.
Data för den ursprungliga IoT-hubben migreras inte. Dessa data omfattar enhetsmeddelanden, C2D-kommandon (moln till enhet) och jobbrelaterad information som scheman och historik. Mått och loggningsresultat migreras inte heller.
Du måste schemalägga stilleståndstid för migreringen. Det tar tid att klona enheterna till den nya hubben. Om du använder import-/exportmetoden har benchmark-testning visat att det kan ta cirka två timmar att flytta 500 000 enheter och fyra timmar att flytta en miljon enheter.
Du kan kopiera enheter till den nya hubben utan att stänga av eller ändra enheterna.
- Om enheterna ursprungligen etablerades med DPS uppdaterar du deras registreringar så att de pekar på den nya IoT-hubben. Etablera sedan om enheterna för att uppdatera anslutningsinformationen som lagras på varje enhet.
- Annars måste du använda import/export-metoden för att flytta enheterna, och sedan måste enheterna ändras för att använda den nya hubben. Du kan till exempel konfigurera enheten så att den använder IoT Hub värdnamnet från de önskade tvillingegenskaperna. Enheten tar IoT Hub värdnamn, kopplar bort enheten från den gamla hubben och återansluter den till den nya.
Du måste uppdatera eventuella certifikat så att du kan använda dem med de nya resurserna. Dessutom har du förmodligen hubben definierad i en DNS-tabell någonstans och behöver uppdatera DNS-informationen.

Metodik

Det här är den allmänna metoden som vi rekommenderar för att migrera en IoT-hubb.

Exportera hubben och dess inställningar till en Resource Manager mall.
Gör nödvändiga ändringar i mallen, till exempel uppdatera alla förekomster av namnet och platsen för den migrerade hubben. För alla resurser i mallen som används för slutpunkter för meddelanderoutning uppdaterar du nyckeln i mallen för den resursen.
Importera mallen till en ny resursgrupp på den nya platsen. Det här steget skapar den nya IoT-hubben.
Felsök efter behov.
Lägg till allt som inte har exporterats till mallen.

Konsumentgrupper exporteras till exempel inte till mallen. Du måste lägga till konsumentgrupper i mallen manuellt eller använda Azure Portal när hubben har skapats.
Kopiera enheterna från den ursprungliga hubben till den nya hubben. Den här processen beskrivs i avsnittet Hantera de enheter som är registrerade på IoT-hubben.

Hantera meddelanderoutning

Om din hubb använder meddelanderoutning inkluderar export av mallen för hubben routningskonfigurationen, men den inkluderar inte själva resurserna. Om du migrerar IoT-hubben till en ny region måste du välja om du vill flytta routningsresurserna till den nya platsen eller lämna dem på plats och fortsätta att använda dem "som de är". Det kan uppstå en liten prestandaträff från att dirigera meddelanden till slutpunktsresurser i en annan region.

Om hubben använder meddelanderoutning har du två alternativ.

Flytta de resurser som används för routningsslutpunkterna till den nya platsen.
1. Skapa de nya resurserna själv antingen manuellt i Azure Portal eller med hjälp av Resource Manager mallar.
2. Byt namn på alla resurser när du skapar dem på den nya platsen, eftersom de kräver globalt unika namn.
3. Uppdatera resursnamnen och resursnycklarna i den nya hubbens mall innan du skapar den nya hubben. Resurserna ska finnas när den nya hubben skapas.
Flytta inte de resurser som används för routningsslutpunkterna. Använd dem "på plats".
1. I steget där du redigerar mallen måste du hämta nycklarna för varje routningsresurs och placera dem i mallen innan du skapar den nya hubben.
2. Hubben refererar fortfarande till de ursprungliga routningsresurserna och dirigerar meddelanden till dem enligt konfigurationen. Du får en liten prestandaträff eftersom hubben och routningsslutpunktsresurserna inte finns på samma plats.

Förbereda migreringen av hubben till en annan region

Det här avsnittet innehåller specifika instruktioner för att migrera hubben.

Exportera den ursprungliga hubben till en resursmall

Logga in på Azure-portalen.
Gå till den IoT-hubb som du vill flytta.
Välj Exportera mall i listan över egenskaper och inställningar för hubben.
Välj Ladda ned för att ladda ned mallen. Spara filen någonstans där du kan hitta den igen.

Visa mallen

Gå till den nedladdade mallen, som finns i en zip-fil. Extrahera zip-filen och leta rätt på filen med namnet template.json.

Följande exempel är för en allmän hubb utan routningskonfiguration. Det är en S1-nivåhubb (med 1 enhet) som heter ContosoHub i regionen westus:

{
    "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "IotHubs_ContosoHub_connectionString": {
            "type": "SecureString"
        },
        "IotHubs_ContosoHub_containerName": {
            "type": "SecureString"
        },
        "IotHubs_ContosoHub_name": {
            "defaultValue": "ContosoHub",
            "type": "String"
        }
    },
    "variables": {},
    "resources": [
        {
            "type": "Microsoft.Devices/IotHubs",
            "apiVersion": "2021-07-01",
            "name": "[parameters('IotHubs_ContosoHub_name')]",
            "location": "westus",
            "sku": {
                "name": "S1",
                "tier": "Standard",
                "capacity": 1
            },
            "identity": {
                "type": "None"
            },
            "properties": {
                "ipFilterRules": [],
                "eventHubEndpoints": {
                    "events": {
                        "retentionTimeInDays": 1,
                        "partitionCount": 4
                    }
                },
                "routing": {
                    "endpoints": {
                        "serviceBusQueues": [],
                        "serviceBusTopics": [],
                        "eventHubs": [],
                        "storageContainers": []
                    },
                    "routes": [],
                    "fallbackRoute": {
                        "name": "$fallback",
                        "source": "DeviceMessages",
                        "condition": "true",
                        "endpointNames": [
                            "events"
                        ],
                        "isEnabled": true
                    }
                },
                "storageEndpoints": {
                    "$default": {
                        "sasTtlAsIso8601": "PT1H",
                        "connectionString": "[parameters('IotHubs_ContosoHub_connectionString')]",
                        "containerName": "[parameters('IotHubs_ContosoHub_containerName')]"
                    }
                },
                "messagingEndpoints": {
                    "fileNotifications": {
                        "lockDurationAsIso8601": "PT1M",
                        "ttlAsIso8601": "PT1H",
                        "maxDeliveryCount": 10
                    }
                },
                "enableFileUploadNotifications": false,
                "cloudToDevice": {
                    "maxDeliveryCount": 10,
                    "defaultTtlAsIso8601": "PT1H",
                    "feedback": {
                        "lockDurationAsIso8601": "PT1M",
                        "ttlAsIso8601": "PT1H",
                        "maxDeliveryCount": 10
                    }
                },
                "features": "None",
                "disableLocalAuth": false,
                "allowedFqdnList": []
            }
        }
    ]
}

Redigera mallen

Du måste göra några ändringar innan du kan använda mallen för att skapa den nya hubben i den nya regionen. Använd Visual Studio Code eller en textredigerare för att redigera mallen.

Redigera hubbens namn och plats

Ta bort parameteravsnittet för containernamn längst upp. ContosoHub har ingen associerad container.

"parameters": {
  ...
    "IotHubs_ContosoHub_containerName": {
        "type": "SecureString"
    },
  ...
},

Ta bort egenskapen storageEndpoints .

"properties": {
  ...
    "storageEndpoints": {
    "$default": {
        "sasTtlAsIso8601": "PT1H",
        "connectionString": "[parameters('IotHubs_ContosoHub_connectionString')]",
        "containerName": "[parameters('IotHubs_ContosoHub_containerName')]"
    }
  },
  ...

Om du flyttar hubben till en ny region ändrar du platsegenskapen under resurser.
```
"location": "westus",
```

Uppdatera routningsslutpunktsresurserna

När du exporterar Resource Manager mallen för en hubb som har konfigurerad routning ser du att nycklarna för dessa resurser inte finns i den exporterade mallen. Deras placering betecknas av asterisker. Du måste fylla i dem genom att gå till resurserna i portalen och hämta nycklarna innan du importerar mallen för den nya hubben och skapar hubben.

Om du även har flyttat routningsresurserna uppdaterar du även namn, ID och resursgrupp för varje slutpunkt.

Hämta de nycklar som krävs för någon av routningsresurserna och placera dem i mallen. Du kan hämta nycklarna från resursen i Azure Portal.
- Om du till exempel dirigerar meddelanden till en lagringscontainer hittar du lagringskontot i portalen. Under avsnittet Inställningar väljer du Åtkomstnycklar och kopierar sedan en av nycklarna. Så här ser nyckeln ut när du först exporterar mallen:
```
"connectionString": "DefaultEndpointsProtocol=https;
AccountName=fabrikamstorage1234;AccountKey=****",
"containerName": "fabrikamresults",
```
  När du har hämtat kontonyckeln för lagringskontot placerar du den i mallen AccountKey=**** i -satsen i stället för asterisker.
- För Service Bus-köer hämtar du den delade åtkomstnyckeln som matchar SharedAccessKeyName. Här är nyckeln och SharedAccessKeyName i json:
```
"connectionString": "Endpoint=sb://fabrikamsbnamespace1234.servicebus.windows.net:5671/;
SharedAccessKeyName=iothubroutes_FabrikamResources;
SharedAccessKey=****;
EntityPath=fabrikamsbqueue1234",
```
- Detsamma gäller för Service Bus-ämnena och Event Hubs-anslutningarna.

Skapa den nya hubben genom att läsa in mallen

Skapa den nya hubben med den redigerade mallen. Om du har routningsresurser som ska flyttas bör resurserna konfigureras på den nya platsen och referenserna i mallen uppdateras så att de matchar. Om du inte flyttar routningsresurserna bör de finnas i mallen med de uppdaterade nycklarna.

Logga in på Azure-portalen.
Välj Skapa en resurs.
I sökrutan söker du efter och väljer malldistribution (distribuera med anpassade mallar). På skärmen för malldistributionen väljer du Skapa.
På sidan Anpassad distribution väljer du Skapa en egen mall i redigeraren, vilket gör att du kan ladda upp mallen från en fil.
Välj Läs in fil.
Bläddra efter den nya mallen som du redigerade och välj den och välj sedan Öppna. Mallen läses in i redigeringsfönstret. Välj Spara.
Fyll i följande fält på sidan för anpassad distribution.

Prenumeration: Välj den prenumeration som du vill använda.

Resursgrupp: Välj en befintlig resursgrupp eller skapa en ny.

Region: Om du har valt en befintlig resursgrupp fylls regionen i så att du kan matcha platsen för resursgruppen. Om du har skapat en ny resursgrupp är det här dess plats.

Anslutningssträng: Fyll i anslutningssträngen för din hubb.

Hubbnamn: Ge den nya hubben ett namn.
Välj knappen Granska + skapa.
Välj knappen Skapa. Portalen validerar mallen och distribuerar din nya hubb. Om du har konfigurationsdata för routning ingår de i den nya hubben, men pekar på resurserna på den tidigare platsen.

Hantera de enheter som är registrerade på IoT-hubben

Nu när du har din nya hubb igång måste du kopiera alla enheter från den ursprungliga hubben till den nya.

Det finns flera sätt att kopiera enheterna. Du använde antingen Device Provisioning Service (DPS) för att etablera enheterna, eller så gjorde du inte det. Om du gjorde det är den här processen inte svår. Om du inte gjorde det kan den här processen vara komplicerad.

Om du inte använde DPS för att etablera dina enheter kan du hoppa över nästa avsnitt och börja med Använd import/export för att flytta enheterna till den nya hubben.

Använda DPS för att återskapa enheterna i den nya hubben

Information om hur du använder DPS för att flytta enheterna till den nya platsen finns i Så här återskapar du enheter. När du är klar kan du visa enheterna i Azure Portal och kontrollera att de finns på den nya platsen.

Gå till den nya hubben med hjälp av Azure Portal. Välj din hubb och välj sedan IoT-enheter. Du ser de enheter som har återskapats till den nya hubben. Du kan också visa egenskaperna för den nya hubben.

Om du har implementerat routning testar du och kontrollerar att dina meddelanden dirigeras till resurserna på rätt sätt.

Återställa ändringarna när du har använt DPS

Om du vill återställa ändringarna ska du återskapa enheterna från den nya hubben till den gamla.

Nu är du klar med att migrera din hubb och dess enheter. Du kan gå vidare till Rensa.

Använda importexport för att flytta enheterna till den nya hubben

Programmet riktar in sig på .NET Core, så att du kan köra det på antingen Windows eller Linux. Du kan ladda ned exemplet, hämta anslutningssträngarna, ange flaggor för vilka bitar du vill köra och köra det. Du kan göra detta utan att behöva öppna koden.

Ladda ned exemplet

Använd IoT C#-exemplen här: Azure IoT SDK för C#. Ladda ned zip-filen och packa upp den på datorn.
Den relevanta koden finns i ./iothub/service/samples/how to guides/ImportExportDevicesSample. Du behöver inte visa eller redigera koden för att kunna köra programmet.
Om du vill köra programmet anger du tre anslutningssträngar och fem alternativ. Du skickar in dessa data som kommandoradsargument eller använder miljövariabler, eller använder en kombination av de två. Vi ska skicka in alternativen som kommandoradsargument och anslutningssträngarna som miljövariabler.

Orsaken till detta är att anslutningssträngarna är långa och icke-bakåtkompatibelt och sannolikt inte kommer att ändras, men du kanske vill ändra alternativen och köra programmet mer än en gång. Om du vill ändra värdet för en miljövariabel måste du stänga kommandofönstret och Visual Studio eller Visual Studio Code, beroende på vilket du använder.

Alternativ

Här är de fem alternativ som du anger när du kör programmet:

addDevices (argument 1) – ange det här alternativet till True om du vill lägga till virtuella enheter som genereras åt dig. Dessa enheter läggs till i källhubben. Ange också numToAdd (argument 2) för att ange hur många enheter du vill lägga till. Det maximala antalet enheter som du kan registrera till en hubb är en miljon. Syftet med det här alternativet är att testa. Du kan generera ett visst antal enheter och sedan kopiera dem till en annan hubb.
copyDevices (argument 3) – ange det här alternativet för att True kopiera enheterna från en hubb till en annan.
deleteSourceDevices (argument 4) – ange det här alternativet för True att ta bort alla enheter som är registrerade i källhubben. Vi rekommenderar att du väntar tills du är säker på att alla enheter har överförts innan du kör detta. När du har tagit bort enheterna kan du inte få tillbaka dem.
deleteDestDevices (argument 5) – ange det här alternativet för True att ta bort alla enheter som är registrerade på målhubben. Du kanske vill göra detta om du vill kopiera enheterna mer än en gång.

Det grundläggande kommandot är dotnet run, som instruerar .NET att skapa den lokala csproj-filen och sedan köra den. Du lägger till kommandoradsargumenten i slutet innan du kör det.

Kommandoraden ser ut så här:

    // Format: dotnet run add-devices num-to-add copy-devices delete-source-devices delete-destination-devices

    // Add 1000 devices, don't copy them to the other hub, or delete them. 
    // The first argument is true, numToAdd is 50, and the other arguments are false.
    dotnet run true 1000 false false false 

    // Copy the devices you just added to the other hub; don't delete anything.
    // The first argument is false, numToAdd is 0, copy-devices is true, and the delete arguments are both false
    dotnet run false 0 true false false

Använda miljövariabler för anslutningssträngarna

Om du vill köra exemplet behöver du anslutningssträngarna till de gamla och nya IoT-hubbarna och till ett lagringskonto som du kan använda för tillfälliga arbetsfiler. Vi lagrar värdena för dessa i miljövariabler.
Om du vill hämta värdena för anslutningssträngen loggar du in på Azure Portal.
Placera anslutningssträngarna någonstans där du kan hämta dem, till exempel Anteckningar. Om du kopierar följande kan du klistra in anslutningssträngarna direkt dit de går. Lägg inte till blanksteg runt likhetstecknet eller ändra variabelnamnet. Du behöver inte heller dubbla citattecken runt anslutningssträngarna. Om du placerar citattecken runt anslutningssträngen för lagringskontot misslyckas skriptet.

Ange miljövariablerna i Windows:
```
SET IOTHUB_CONN_STRING=<put connection string to original IoT hub here>
SET DEST_IOTHUB_CONN_STRING=<put connection string to destination IoT hub here>
SET STORAGE_ACCT_CONN_STRING=<put connection string to the storage account here>
```
Ange miljövariablerna i Linux:
```
export IOTHUB_CONN_STRING="<put connection string to original IoT hub here>"
export DEST_IOTHUB_CONN_STRING="<put connection string to destination IoT hub here>"
export STORAGE_ACCT_CONN_STRING="<put connection string to the storage account here>"
```
För IoT Hub-anslutningssträngarna går du till varje hubb i portalen. Du kan söka i Resurser efter hubben. Om du känner till resursgruppen kan du gå till Resursgrupper, välja din resursgrupp och sedan välja hubben i listan över tillgångar i resursgruppen.
Välj Principer för delad åtkomst från Inställningar för hubben och välj sedan iothubowner och kopiera en av anslutningssträngarna. Gör samma sak för målhubben. Lägg till dem i lämpliga SET-kommandon.
För anslutningssträngen för lagringskontot letar du upp lagringskontot i Resurser eller under dess resursgrupp och öppnar det.
Under avsnittet Inställningar väljer du Åtkomstnycklar och kopierar en av anslutningssträngarna. Placera anslutningssträngen i textfilen för lämpligt SET-kommando.

Nu har du miljövariablerna i en fil med SET-kommandona och du vet vad dina kommandoradsargument är. Nu ska vi köra exemplet.

Kör exempelprogrammet och använd kommandoradsargument

Öppna ett kommandotolksfönster. Välj Windows och skriv in command prompt för att hämta kommandotolkens fönster.
Kopiera de kommandon som anger miljövariablerna, en i taget, och klistra in dem i kommandotolkens fönster och välj Retur. När du är klar skriver SET du i kommandotolkens fönster för att se dina miljövariabler och deras värden. När du har kopierat dessa till kommandotolken behöver du inte kopiera dem igen, såvida du inte öppnar ett nytt kommandotolksfönster.
I kommandotolkens fönster ändrar du kataloger tills du befinner dig i ./ImportExportDevicesSample (där filen ImportExportDevicesSample.csproj finns). Skriv sedan följande och inkludera dina kommandoradsargument.
```
// Format: dotnet run add-devices num-to-add copy-devices delete-source-devices delete-destination-devices
dotnet run arg1 arg2 arg3 arg4 arg5
```
Dotnet-kommandot skapar och kör programmet. Eftersom du skickar in alternativen när du kör programmet kan du ändra värdena för dem varje gång du kör programmet. Du kanske till exempel vill köra den en gång och skapa nya enheter, sedan köra den igen och kopiera enheterna till en ny hubb och så vidare. Du kan också utföra alla steg i samma körning, även om vi rekommenderar att du inte tar bort några enheter förrän du är säker på att du är klar med migreringen. Här är ett exempel som skapar 1 000 enheter och sedan kopierar dem till den andra hubben.
```
// Format: dotnet run add-devices num-to-add copy-devices delete-source-devices delete-destination-devices

// Add 1000 devices, don't copy them to the other hub or delete them. 
dotnet run true 1000 false false false 

// Do not add any devices. Copy the ones you just created to the other hub; don't delete anything.
dotnet run false 0 true false false 
```
När du har kontrollerat att enheterna har kopierats kan du ta bort enheterna från källhubben så här:
```
// Format: dotnet run add-devices num-to-add copy-devices delete-source-devices delete-destination-devices
// Delete the devices from the source hub.
dotnet run false 0 false true false 
```

Köra exempelprogrammet med Visual Studio

Om du vill köra programmet i Visual Studio ändrar du din aktuella katalog till mappen där filen azureiot.sln finns. Kör sedan det här kommandot i kommandotolken för att öppna lösningen i Visual Studio. Du måste göra detta i samma kommandofönster där du anger miljövariablerna, så att dessa variabler är kända.
```
azureiot.sln
```
Högerklicka på projektet ImportExportDevicesSample och välj Ange som startprojekt.

Ange variablerna överst i Program.cs i mappen ImportExportDevicesSample för de fem alternativen.

// Add randomly created devices to the source hub.
private static bool addDevices = true;
//If you ask to add devices, this will be the number added.
private static int numToAdd = 0; 
// Copy the devices from the source hub to the destination hub.
private static bool copyDevices = false;
// Delete all of the devices from the source hub. (It uses the IoTHubConnectionString).
private static bool deleteSourceDevices = false;
// Delete all of the devices from the destination hub. (Uses the DestIotHubConnectionString).
private static bool deleteDestDevices = false;

Välj F5 för att köra programmet. När körningen är klar kan du visa resultatet.

Visa resultatet

Du kan visa enheterna i Azure Portal och kontrollera att de finns på den nya platsen.

Gå till den nya hubben med hjälp av Azure Portal. Välj din hubb och välj sedan IoT-enheter. Du ser de enheter som du kopierade från den gamla hubben till den nya hubben. Du kan också visa egenskaperna för den nya hubben.
Sök efter import-/exportfel genom att gå till Azure Storage-kontot i Azure Portal och leta i containern devicefilesImportErrors.logför . Om den här filen är tom (storleken är 0) uppstod inga fel. Om du försöker importera samma enhet mer än en gång avvisar den enheten andra gången och lägger till ett felmeddelande i loggfilen.

Checka in ändringarna

Nu har du kopierat hubben till den nya platsen och migrerat enheterna till den nya hubben. Nu måste du göra ändringar så att enheterna fungerar med den nya hubben.

För att genomföra ändringarna måste du utföra följande steg:

Uppdatera varje enhet för att ändra IoT Hub värdnamn så att IoT Hub värdnamn pekar på den nya hubben. Du bör göra detta med samma metod som du använde när du först etablerade enheten.
Ändra alla program som refererar till den gamla hubben så att de pekar på den nya hubben.
När du är klar bör den nya hubben vara igång. Den gamla hubben ska inte ha några aktiva enheter och vara i frånkopplat tillstånd.

Återställa ändringarna

Om du bestämmer dig för att återställa ändringarna följer du stegen nedan:

Uppdatera varje enhet för att ändra IoT Hub värdnamn så att det pekar IoT Hub värdnamn för den gamla hubben. Du bör göra detta med samma metod som du använde när du först etablerade enheten.
Ändra alla program som refererar till den nya hubben så att de pekar på den gamla hubben. Om du till exempel använder Azure Analytics kan du behöva konfigurera om dina Azure Stream Analytics-indata.
Ta bort den nya hubben.
Om du har routningsresurser bör konfigurationen på den gamla hubben fortfarande peka på rätt routningskonfiguration och bör fungera med dessa resurser när hubben har startats om.

Kontrollera resultaten

Om du vill kontrollera resultaten ändrar du din IoT-lösning så att den pekar på hubben på den nya platsen och kör den. Med andra ord utför du samma åtgärder med den nya hubben som du utförde med föregående hubb och ser till att de fungerar korrekt.