Merge pull request #288703 from MicrosoftDocs/repo_sync_working_branch

Confirm merge from repo_sync_working_branch to main to sync with https://github.com/MicrosoftDocs/azure-docs (branch main)

Author: Daidihuang

articles/baremetal-infrastructure/workloads/nc2-on-azure/architecture.md

@@ -118,6 +118,7 @@ When planning your NC2 on Azure design, use the following table to understand wh
 | Japan East | AN36P |
 | North Central US | AN36P |
 | Southeast Asia | AN36P |
+| UAE North | AN36P |
 | UK South | AN36P |
 | West Europe | AN36P |
 | West US 2 | AN36 |

articles/event-grid/event-schema-blob-storage.md

@@ -101,6 +101,8 @@ These events are triggered when a client creates, replaces, or deletes a blob by
 		"contentType": "image/jpeg",
 		"contentLength": 105891,
 		"blobType": "BlockBlob",
+		"accessTier": "Archive",
+		"previousTier": "Cool",
 		"url": "https://my-storage-account.blob.core.windows.net/testcontainer/Auto.jpg",
 		"sequencer": "000000000000000000000000000089A4000000000018d6ea",
 		"storageDiagnostics": {
@@ -208,6 +210,8 @@ These events are triggered when a client creates, replaces, or deletes a blob by
 		"contentType": "image/jpeg",
 		"contentLength": 105891,
 		"blobType": "BlockBlob",
+		"accessTier": "Archive",
+        	"previousTier": "Cool",
 		"url": "https://my-storage-account.blob.core.windows.net/testcontainer/Auto.jpg",
 		"sequencer": "000000000000000000000000000089A4000000000018d6ea",
 		"storageDiagnostics": {
@@ -1246,6 +1250,8 @@ The data object has the following properties:
 | `contentType` | string | The content type specified for the blob. |
 | `contentLength` | integer | The size of the blob in bytes. |
 | `blobType` | string | The type of blob. Valid values are either "BlockBlob" or "PageBlob". |
+| `accessTier`     | string    | The target tier of the blob. Appears only for the event BlobTierChanged.                                                                                                                                     |
+| `previousTier`   | string    | The source tier of the blob. Appears only for the event BlobTierChanged. If the blob is inferring the tier from the storage account, this field will not appear.                                          |
 | `contentOffset` | number | The offset in bytes of a write operation taken at the point where the event-triggering application completed writing to the file. <br>Appears only for events triggered on blob storage accounts that have a hierarchical namespace.|
 | `destinationUrl` |string | The url of the file that will exist after the operation completes. For example, if a file is renamed, the `destinationUrl` property contains the url of the new file name. <br>Appears only for events triggered on blob storage accounts that have a hierarchical namespace.|
 | `sourceUrl` |string | The url of the file that exists before the operation is done. For example, if a file is renamed, the `sourceUrl` contains the url of the original file name before the rename operation. <br>Appears only for events triggered on blob storage accounts that have a hierarchical namespace. |

articles/event-hubs/event-hubs-go-get-started-send.md

@@ -49,47 +49,58 @@ Here's the code to send events to an event hub. The main steps in the code are:
 package main
 
 import (
-    "context"
+	"context"
 
-    "github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs"
+	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs"
 )
 
 func main() {
+	// create an Event Hubs producer client using a connection string to the namespace and the event hub
+	producerClient, err := azeventhubs.NewProducerClientFromConnectionString("NAMESPACE CONNECTION STRING", "EVENT HUB NAME", nil)
 
-    // create an Event Hubs producer client using a connection string to the namespace and the event hub
-    producerClient, err := azeventhubs.NewProducerClientFromConnectionString("NAMESPACE CONNECTION STRING", "EVENT HUB NAME", nil)
+	if err != nil {
+		panic(err)
+	}
 
-    if err != nil {
-        panic(err)
-    }
+	defer producerClient.Close(context.TODO())
 
-    defer producerClient.Close(context.TODO())
+	// create sample events
+	events := createEventsForSample()
 
-    // create sample events
-    events := createEventsForSample()
+	// create a batch object and add sample events to the batch
+	newBatchOptions := &azeventhubs.EventDataBatchOptions{}
 
-    // create a batch object and add sample events to the batch
-    newBatchOptions := &azeventhubs.EventDataBatchOptions{}
+	batch, err := producerClient.NewEventDataBatch(context.TODO(), newBatchOptions)
 
-    batch, err := producerClient.NewEventDataBatch(context.TODO(), newBatchOptions)
+	if err != nil {
+		panic(err)
+	}
 
-    for i := 0; i < len(events); i++ {
-        err = batch.AddEventData(events[i], nil)
-    }
+	for i := 0; i < len(events); i++ {
+		err = batch.AddEventData(events[i], nil)
 
-    // send the batch of events to the event hub
-    producerClient.SendEventDataBatch(context.TODO(), batch, nil)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	// send the batch of events to the event hub
+	err = producerClient.SendEventDataBatch(context.TODO(), batch, nil)
+
+	if err != nil {
+		panic(err)
+	}
 }
 
 func createEventsForSample() []*azeventhubs.EventData {
-    return []*azeventhubs.EventData{
-        {
-            Body: []byte("hello"),
-        },
-        {
-            Body: []byte("world"),
-        },
-    }
+	return []*azeventhubs.EventData{
+		{
+			Body: []byte("hello"),
+		},
+		{
+			Body: []byte("world"),
+		},
+	}
 }
 ```
 
@@ -134,101 +145,104 @@ Here's the code to receive events from an event hub. The main steps in the code
 package main
 
 import (
-    "context"
-    "errors"
-    "fmt"
-    "time"
-
-    "github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs"
-    "github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs/checkpoints"
-    "github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/container"
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs"
+	"github.com/Azure/azure-sdk-for-go/sdk/messaging/azeventhubs/checkpoints"
+	"github.com/Azure/azure-sdk-for-go/sdk/storage/azblob/container"
 )
 
 func main() {
 
-    // create a container client using a connection string and container name
-    checkClient, err := container.NewClientFromConnectionString("AZURE STORAGE CONNECTION STRING", "CONTAINER NAME", nil)
-    
-    // create a checkpoint store that will be used by the event hub
-    checkpointStore, err := checkpoints.NewBlobStore(checkClient, nil)
+	// create a container client using a connection string and container name
+	checkClient, err := container.NewClientFromConnectionString("AZURE STORAGE CONNECTION STRING", "CONTAINER NAME", nil)
+
+	if err != nil {
+		panic(err)
+	}
 
-    if err != nil {
-        panic(err)
-    }
+	// create a checkpoint store that will be used by the event hub
+	checkpointStore, err := checkpoints.NewBlobStore(checkClient, nil)
 
-    // create a consumer client using a connection string to the namespace and the event hub
-    consumerClient, err := azeventhubs.NewConsumerClientFromConnectionString("NAMESPACE CONNECTION STRING", "EVENT HUB NAME", azeventhubs.DefaultConsumerGroup, nil)
+	if err != nil {
+		panic(err)
+	}
 
-    if err != nil {
-        panic(err)
-    }
+	// create a consumer client using a connection string to the namespace and the event hub
+	consumerClient, err := azeventhubs.NewConsumerClientFromConnectionString("NAMESPACE CONNECTION STRING", "EVENT HUB NAME", azeventhubs.DefaultConsumerGroup, nil)
 
-    defer consumerClient.Close(context.TODO())
+	if err != nil {
+		panic(err)
+	}
 
-    // create a processor to receive and process events
-    processor, err := azeventhubs.NewProcessor(consumerClient, checkpointStore, nil)
+	defer consumerClient.Close(context.TODO())
 
-    if err != nil {
-        panic(err)
-    }
+	// create a processor to receive and process events
+	processor, err := azeventhubs.NewProcessor(consumerClient, checkpointStore, nil)
 
-    //  for each partition in the event hub, create a partition client with processEvents as the function to process events
-    dispatchPartitionClients := func() {
-        for {
-            partitionClient := processor.NextPartitionClient(context.TODO())
+	if err != nil {
+		panic(err)
+	}
 
-            if partitionClient == nil {
-                break
-            }
+	//  for each partition in the event hub, create a partition client with processEvents as the function to process events
+	dispatchPartitionClients := func() {
+		for {
+			partitionClient := processor.NextPartitionClient(context.TODO())
 
-            go func() {
-                if err := processEvents(partitionClient); err != nil {
-                    panic(err)
-                }
-            }()
-        }
-    }
+			if partitionClient == nil {
+				break
+			}
 
-    // run all partition clients
-    go dispatchPartitionClients()
+			go func() {
+				if err := processEvents(partitionClient); err != nil {
+					panic(err)
+				}
+			}()
+		}
+	}
 
-    processorCtx, processorCancel := context.WithCancel(context.TODO())
-    defer processorCancel()
+	// run all partition clients
+	go dispatchPartitionClients()
 
-    if err := processor.Run(processorCtx); err != nil {
-        panic(err)
-    }
+	processorCtx, processorCancel := context.WithCancel(context.TODO())
+	defer processorCancel()
+
+	if err := processor.Run(processorCtx); err != nil {
+		panic(err)
+	}
 }
 
 func processEvents(partitionClient *azeventhubs.ProcessorPartitionClient) error {
-    defer closePartitionResources(partitionClient)
-    for {
-        receiveCtx, receiveCtxCancel := context.WithTimeout(context.TODO(), time.Minute)
-        events, err := partitionClient.ReceiveEvents(receiveCtx, 100, nil)
-        receiveCtxCancel()
-
-        if err != nil && !errors.Is(err, context.DeadlineExceeded) {
-            return err
-        }
-
-        fmt.Printf("Processing %d event(s)\n", len(events))
-
-        for _, event := range events {
-            fmt.Printf("Event received with body %v\n", string(event.Body))
-        }
-
-        if len(events) != 0 {
-            if err := partitionClient.UpdateCheckpoint(context.TODO(), events[len(events)-1]); err != nil {
-                return err
-            }
-        }
-    }
+	defer closePartitionResources(partitionClient)
+	for {
+		receiveCtx, receiveCtxCancel := context.WithTimeout(context.TODO(), time.Minute)
+		events, err := partitionClient.ReceiveEvents(receiveCtx, 100, nil)
+		receiveCtxCancel()
+
+		if err != nil && !errors.Is(err, context.DeadlineExceeded) {
+			return err
+		}
+
+		fmt.Printf("Processing %d event(s)\n", len(events))
+
+		for _, event := range events {
+			fmt.Printf("Event received with body %v\n", string(event.Body))
+		}
+
+		if len(events) != 0 {
+			if err := partitionClient.UpdateCheckpoint(context.TODO(), events[len(events)-1], nil); err != nil {
+				return err
+			}
+		}
+	}
 }
 
 func closePartitionResources(partitionClient *azeventhubs.ProcessorPartitionClient) {
-    defer partitionClient.Close(context.TODO())
+	defer partitionClient.Close(context.TODO())
 }
-
 ```
 
 ## Run receiver and sender apps

articles/migrate/tutorial-migrate-physical-virtual-machines.md

@@ -1,7 +1,7 @@
 ---
 title: Migrate machines as physical servers to Azure with Azure Migrate and Modernize
 description: This article describes how to migrate physical machines to Azure with Azure Migrate and Modernize.
-author: vijain
+author: pingvishal-msft
 ms.author: vijain
 ms.manager: kmadnani
 ms.topic: tutorial
@@ -199,7 +199,7 @@ Now, select machines for migration.
 
     :::image type="content" source="./media/tutorial-migrate-physical-virtual-machines/select-vms-inline.png" alt-text="Screenshot that shows selecting VMs." lightbox="./media/tutorial-migrate-physical-virtual-machines/select-vms-expanded.png":::
 
-1. In **Target settings**, select the subscription and target region to which you'll migrate. Specify the resource group in which the Azure VMs will reside after migration.
+1. In **Target settings**, select the subscription to which you'll migrate. (The region is set to your selection in the previous step and can't be modified.) Specify the resource group in which the Azure VMs will reside after migration.
 1. In **Virtual Network**, select the Azure virtual network/subnet to which the Azure VMs will be joined after migration.
 1. In **Cache storage account**, keep the default option to use the cache storage account that's automatically created for the project. Use the dropdown list if you want to specify a different storage account to use as the cache storage account for replication. <br/>