-The below example shows how a [docker compose](https://docs.docker.com/compose/reference/overview) file can be created to deploy NGINX and health containers:

-You can use Postman or the example cURL request below to submit a query to the container you deployed, replacing the `serverURL` variable with the appropriate value. Note the version of the API in the URL for the container is different than the hosted API.

-The **Publish** page also provides information to [generate an answer](../quickstarts/get-answer-from-knowledge-base-using-url-tool.md) with Postman or cURL.

-> [Get answer with Postman or cURL](get-answer-from-knowledge-base-using-url-tool.md)

-description: This article walks you through getting an answer from your knowledge base using a URL test tool such as cURL or Postman.

-## func init

-## func logs

-## func new

-## func run

-## func start

-# [v2.x+](#tab/v2)

-# [v1.x](#tab/v1)

-## func azure functionapp fetch-app-settings

-`func azure functionapp fetch-app-settings` supports these optional arguments:

-| Option | Description |

-| | -- |

-| **`--access-token`** | Lets you use a specific access token when performing authenticated `azure` actions. |

-| **`--access-token-stdin `** | Reads a specific access token from a standard input. Use this when reading the token directly from a previous command such as [`az account get-access-token`](/cli/azure/account#az-account-get-access-token). |

-| **`--management-url`** | Sets the management URL for your cloud. Use this when running in a sovereign cloud. |

-| **`--slot`** | Optional name of a specific slot to which to publish. |

-| **`--subscription`** | Sets the default subscription to use. |

-## func azure functionapp list-functions

-`func azure functionapp list-functions` supports these optional arguments:

-| Option | Description |

-| | -- |

-| **`--access-token`** | Lets you use a specific access token when performing authenticated `azure` actions. |

-| **`--access-token-stdin `** | Reads a specific access token from a standard input. Use this when reading the token directly from a previous command such as [`az account get-access-token`](/cli/azure/account#az-account-get-access-token). |

-| **`--management-url`** | Sets the management URL for your cloud. Use this when running in a sovereign cloud. |

-| **`--show-keys`** | Shows HTTP function endpoint URLs that include their default access keys. These URLs can be used to access function endpoints with `function` level [HTTP authentication](functions-bindings-http-webhook-trigger.md#http-auth). |

-| **`--slot`** | Optional name of a specific slot to which to publish. |

-| **`--subscription`** | Sets the default subscription to use. |

-## func azure functionapp logstream

-The `func azure functionapp logstream` command supports these optional arguments:

-| **`--access-token`** | Lets you use a specific access token when performing authenticated `azure` actions. |

-| **`--access-token-stdin `** | Reads a specific access token from a standard input. Use this when reading the token directly from a previous command such as [`az account get-access-token`](/cli/azure/account#az-account-get-access-token). |

-| **`--management-url`** | Sets the management URL for your cloud. Use this when running in a sovereign cloud. |

-| **`--slot`** | Optional name of a specific slot to which to publish. |

-| **`--subscription`** | Sets the default subscription to use. |

-## func azure functionapp publish

-| **`--show-keys`** | Shows HTTP function endpoint URLs that include their default access keys. These URLs can be used to access function endpoints with `function` level [HTTP authentication](functions-bindings-http-webhook-trigger.md#http-auth). |

-## func azure storage fetch-connection-string

-## func azurecontainerapps deploy

-## func deploy

-## func durable delete-task-hub

-## func durable get-history

-## func durable get-instances

-## func durable get-runtime-status

-## func durable purge-history

-## func durable raise-event

-## func durable rewind

-## func durable start-new

-## func durable terminate

-## func extensions install

-## func extensions sync

-## func kubernetes deploy

-## func kubernetes install

-## func kubernetes remove

-## func settings add

-## func settings decrypt

-## func settings delete

-## func settings encrypt

-## func settings list

-## func templates list

-If a profile's date and time settings match the current time, autoscale will apply that profile's rules and capacity limits. Only the first applicable profile is used.

-The example below shows an autoscale setting with a default profile and recurring profile.

-In the above example, on Monday after 3 AM, the recurring profile will cease to be used. If the instance count is less than 3, autoscale scales to the new minimum of three. Autoscale continues to use this profile and scales based on CPU% until Monday at 8 PM. At all other times scaling will be done according to the default profile, based on the number of requests. After 8 PM on Monday, autoscale switches to the default profile. If for example, the number of instances at the time is 12, autoscale scales in to 10, which the maximum allowed for the default profile.

-In the portal, the end time field becomes the next start time for the default profile. You can't specify the same time for the end of one profile and the start of the next. The portal will force the end time to be one minute before the start time of the following profile. During this minute, the default profile will become active. If you don't want the default profile to become active between recurring profiles, leave the end time field empty.

-There is no specification in the template for end time. A profile will remain active until the next profile's start time.

-The example below shows how to create two recurring profiles. One profile for weekends from 00:01 on Saturday morning and a second Weekday profile starting on Mondays at 04:00. That means that the weekend profile will start on Saturday morning at one minute passed midnight and end on Monday morning at 04:00. The Weekday profile will start at 4am on Monday and end just after midnight on Saturday morning.

-where *VMSS1-autoscale.json* is the file containing the JSON object below.

- "targetResourceUri": "/subscriptions/abc123456-987-f6e5-d43c-9a8d8e7f6541/resourceGroups/rg-vmss1/providers/Microsoft.Compute/virtualMachineScaleSets/VMSS1",

- "metricResourceUri": "/subscriptions/abc123456-987-f6e5-d43c-9a8d8e7f6541/resourceGroups/rg-vmss1/providers/Microsoft.Compute/virtualMachineScaleSets/VMSS1",

- "metricResourceUri": "/subscriptions/abc123456-987-f6e5-d43c-9a8d8e7f6541/resourceGroups/rg-vmss1/providers/Microsoft.Compute/virtualMachineScaleSets/VMSS1",

-The example below shows how to add a recurring autoscale profile, recurring on Thursdays between 06:00 and 22:50.

-export autoscaleName=vmss-autoscalesetting=002

-See the [PowerShell Az.Monitor Reference](/powershell/module/az.monitor/#monitor) for the full set of autoscale PowerShell commands.

-The example below shows how to create default profile and a recurring autoscale profile, recurring on Wednesdays and Fridays between 09:00 and 23:00.

-$TargetResourceId="/subscriptions/abc123456-987-f6e5-d43c-9a8d8e7f6541/resourceGroups/rg-vmss-001/providers/Microsoft.Compute/virtualMachineScaleSets/vmss-001"

-You can send email to any valid email address when an autoscale event occurs. Administrators and co-administrators of the subscription where the rule is running are also notified.

-Select the check boxes to send an email to the subscription administrator or co-administrators. You can also enter a list of email addresses to send notifications to.

-+ `--add-action` - The action to take when the autoscale rule is triggered. The value must be `email` or `webhook`.

-+ `--email-administrator {false, true}` - Send email to the subscription administrator.

-+ `--email-coadministrators {false, true}` - Send email to the subscription co-administrators.

-For example, the following command adds an email notification and a webhook notification to and existing autoscale setting. The command also sends email to the subscription administrator.

-| operation |Yes |Value must be "Scale." |

-| sendToSubscriptionAdministrator |Yes |Value must be "true" or "false." |

-| sendToSubscriptionCoAdministrators |Yes |Value must be "true" or "false." |

-| customEmails |Yes |Value can be null [] or a string array of emails. |

-| webhooks |Yes |Value can be null or valid URI. |

-| serviceUri |Yes |Valid HTTPS URI. |

-| properties |Yes |Value must be empty {} or can contain key-value pairs. |

- "id": "/subscriptions/123456ab-9876-a1b2-a2b1-123a567b9f8767/resourceGroups/rg-001/providers/microsoft.insights/autoscalesettings/AutoscaleSettings-002",

- "subscriptionId": "123456ab-9876-a1b2-a2b1-123a567b9f8767",

- "resourceId": "/subscriptions/123456ab-9876-a1b2-a2b1-123a567b9f8767/resourceGroups/rg-001/providers/Microsoft.Web/serverfarms/ScaleableAppServicePlan",

- "portalLink": "https://portal.azure.com/#resource/subscriptions/123456ab-9876-a1b2-a2b1-123a567b9f8767/resourceGroups/rg-001/providers/Microsoft.Web/serverfarms/ScaleableAppServicePlan",

-## Kusto Query Language (KQL) and Log Analytics

-You retrieve data from a Log Analytics workspace using a [Kusto Query Language (KQL)](/azure/data-explorer/kusto/query/) query, which is a read-only request to process data and return results. KQL is a powerful tool that can analyze millions of records quickly. Use KQL to explore your logs, transform and aggregate data, discover patterns, identify anomalies and outliers, and more.

-Log Analytics is a tool in the Azure portal for running log queries and analyzing their results. [Log Analytics Simple mode](log-analytics-simple-mode.md) lets any user, regardless of their knowledge of KQL, retrieve data from one or more tables with one click. A set of controls lets you explore and analyze the retrieved data using the most popular Azure Monitor Logs functionality in an intuitive, spreadsheet-like experience.

-If you're familiar with KQL, you can use Log Analytics KQL mode to edit and create queries, which you can then use in Azure Monitor features such as alerts and workbooks, or share with other users.

-For more information about Log Analytics, see [Overview of Log Analytics in Azure Monitor](./log-analytics-overview.md).

-## Built-in insights and custom dashboards, workbooks, and reports

-Many of Azure Monitor's [ready-to-use, curated Insights experiences](../insights/insights-overview.md) store data in Azure Monitor Logs, and present this data in an intuitive way so you can monitor the performance and availability of your cloud and hybrid applications and their supporting components.

-You can also [create your own visualizations and reports](../best-practices-analysis.md#built-in-visualization-tools) using workbooks, dashboards, and Power BI.

-## Data collection, routing, and transformation

-Azure Monitor's data collection capabilities let you collect data from all of your applications and resources running in Azure, other clouds, and on-premises. A powerful ingestion pipeline enables filtering, transforming, and routing data to destination tables in your Log Analytics workspace to optimize costs, analytics capabilities, and query performance.

-For more information on data collection and transformation, see [Azure Monitor data sources and data collection methods](../data-sources.md) and [Data collection transformations in Azure Monitor](../essentials/data-collection-transformations.md).

-Azure IoT Hub Device Provisioning Service (DPS) can provision devices across one or more IoT hubs. Before DPS can provision devices to an IoT hub, it must be linked to your DPS instance. Once linked, an IoT hub can be used in an allocation policy. Allocation policies determine how devices are assigned to IoT hubs by DPS. This article provides instruction on how to link IoT hubs and manage them in your DPS instance.

-## Linked IoT hubs and allocation policies

-DPS can only provision devices to IoT hubs that have been linked to it. Linking an IoT hub to a DPS instance gives the service read/write permissions to the IoT hub's device registry. With these permissions, DPS can register a device ID and set the initial configuration in the device twin. Linked IoT hubs may be in any Azure region. You may link hubs in other subscriptions to your DPS instance.

-After an IoT hub is linked to DPS, it's eligible to participate in allocation. Whether and how it will participate in allocation depends on settings in the enrollment that a device provisions through and settings on the linked IoT hub itself.

-* **Connection string**: Sets the IoT Hub connection string that DPS uses to connect to the linked IoT hub. The connection string is based on one of the IoT hub's shared access policies. DPS needs the following permissions on the IoT hub: *RegistryWrite* and *ServiceConnect*. The connection string must be for a shared access policy that has these permissions. To learn more about IoT Hub shared access policies, see [IoT Hub access control and permissions](../iot-hub/iot-hub-dev-guide-sas.md#access-control-and-permissions).

-* **Apply allocation policy**: Sets whether the IoT hub participates in allocation policy. The default is **Yes** (true). If set to **No** (false), devices won't be assigned to the IoT hub. The IoT hub can still be selected on an enrollment, but it won't participate in allocation. You can use this setting to temporarily or permanently remove an IoT hub from participating in allocation; for example, if it's approaching the allowed number of devices.

-## Add a linked IoT hub

-When you link an IoT hub to your DPS instance, it becomes available to participate in allocation. You can add IoT hubs that are inside or outside of your subscription. When you link an IoT hub, it may or may not be available for allocations in existing enrollments:

-* For enrollments that don't explicitly set the IoT hubs to apply allocation policy to, a newly linked IoT hub immediately begins participating in allocation.

-* For enrollments that do explicitly set the IoT hubs to apply allocation policy to, you'll need to manually or programmatically add the new IoT hub to the enrollment settings for it to participate in allocation.

-### Limitations

-* There are some limitations when working with linked IoT hubs and private endpoints. For more information, see [Private endpoint limitations](virtual-network-support.md#private-endpoint-limitations).

-* The linked IoT Hub must have [Connect using shared access policies](../iot-hub/iot-hub-dev-guide-azure-ad-rbac.md#azure-ad-access-and-shared-access-policies) set to **Allow**.

-### Use the Azure portal to link an IoT hub

-When you're creating or updating an enrollment, you can use the **Link a new IoT hub** button on the enrollment. You'll be presented with the same page and choices as above. After you save the linked hub, it will be available on your DPS instance and can be selected from your enrollment.

-> In the Azure portal, you can't set the *Allocation weight* and *Apply allocation policy* settings when you add a linked IoT hub. Instead, You can update these settings after the IoT hub is linked. To learn more, see [Update a linked IoT hub](#update-a-linked-iot-hub).

-### Use the Azure CLI to link an IoT hub

-### Use the Azure portal to update a linked IoT hub

- :::image type="content" source="media/how-to-manage-linked-iot-hubs/set-linked-iot-hub-properties.png" alt-text="Screenshot that shows the linked IoT hub details page.":::.

-> You can't update the connection string that DPS uses to connect to the IoT hub from the Azure portal. Instead, you can use the Azure CLI to update the connection string, or you can delete the linked IoT hub from your DPS instance and relink it. To learn more, see [Update keys for linked IoT hubs](#update-keys-for-linked-iot-hubs).

-### Use the Azure CLI to update a linked IoT hub

-When you delete a linked IoT hub from your DPS instance, it will no longer be available to set in future enrollments. However, it may or may not be removed from allocations in existing enrollments:

-* For enrollments that do explicitly set the IoT hubs to apply allocation policy to, you'll need to manually or programmatically remove the IoT hub from the enrollment settings for it to be removed from participation in allocation. Failure to do so may result in an error when a device tries to provision through the enrollment.

-### Use the Azure portal to delete a linked IoT hub

-### Use the Azure CLI to delete a linked IoT hub

-It may become necessary to either rotate or update the symmetric keys for an IoT hub that's been linked to DPS. In this case, you'll also need to update the connection string setting in DPS for the linked IoT hub. Note that provisioning to an IoT hub will fail during the interim between updating a key on the IoT hub and updating your DPS instance with the new connections string based on that key. For this reason, we recommend [using the Azuer CLI to update your keys](#use-the-azure-cli-to-update-keys) because you can update the connnection string on the linked hub direcctly. With the Azure portal, you have to delete the IoT hub from your DPS instance and then relink it in order to update the connection string.

-### Use the Azure portal to update keys

-You can't update the connection string setting for a linked IoT Hub when using Azure portal. Instead, you need to delete the linked IoT hub from your DPS instance and then re-add it.

-1. On the left menu of your DPS instance in the Azure portal, select the IoT hub that you want to update the key(s) for.

-1. On the **Linked IoT hub details** page, note down the values for *Allocation weight* and *Apply allocation policy*, you'll need these values when you relink the IoT hub to your DPS instance later. Then, select **Manage Resource** to go to the IoT hub.

-1. Follow the steps in [Delete an IoT hub](#use-the-azure-portal-to-delete-a-linked-iot-hub) to delete the IoT hub from your DPS instance.

-1. Follow the steps in [Link an IoT hub](#use-the-azure-portal-to-link-an-iot-hub) to relink the IoT hub to your DPS instance with the new connection string for the policy.

-1. If you need to restore the allocation weight and apply allocation policy settings, follow the steps in [Update a linked IoT hub](#use-the-azure-portal-to-update-a-linked-iot-hub) using the values you saved in step 2.

-### Use the Azure CLI to update keys

- The output will show the position of the linked IoT hub you want to update the connection string for in the table of linked IoT hubs maintained by your DPS instance. In this case, it's the first IoT hub in the list, *MyExampleHub*.

- 1. Optionally, you can select the **Link a new IoT hub** button to link a new IoT hub to the DPS instance and make it available in the list of IoT hubs that can be selected. For details about linking an IoT hub, see [Link an IoT Hub](how-to-manage-linked-iot-hubs.md#use-the-azure-portal-to-link-an-iot-hub).

-Azure Machine Learning prompt flow is a development tool designed to streamline the entire development cycle of AI applications powered by Large Language Models (LLMs). As the momentum for LLM-based AI applications continues to grow across the globe, Azure Machine Learning prompt flow provides a comprehensive solution that simplifies the process of prototyping, experimenting, iterating, and deploying your AI applications.

-With Azure Machine Learning prompt flow, you'll be able to:

-If you're looking for a versatile and intuitive development tool that will streamline your LLM-based AI application development, then Azure Machine Learning prompt flow is the perfect solution for you. Get started today and experience the power of streamlined development with Azure Machine Learning prompt flow.

-With Azure Machine Learning prompt flow, users can unleash their prompt engineering agility, collaborate effectively, and leverage enterprise-grade solutions for successful LLM-based application development and deployment.

-Azure Machine Learning prompt flow offers a well-defined process that facilitates the seamless development of AI applications. By leveraging it, you can effectively progress through the stages of developing, testing, tuning, and deploying flows, ultimately resulting in the creation of fully fledged AI applications.

-By following this structured and methodical approach, prompt flow empowers you to develop, rigorously test, fine-tune, and deploy flows with confidence, resulting in the creation of robust and sophisticated AI applications.

-* Python 3.6 or 3.7 are supported for this feature

-description: Learn about considerations for customers to plan for before they deploy applications in an Azure public multi-access edge compute (MEC) solution.

-# Considerations for deployment in Azure public MEC

-Azure public multi-access edge compute (MEC) sites are small-footprint extensions of Azure. They're placed in or near mobile operators' data centers in metro areas, and are designed to run workloads that require low latency while being attached to the mobile network. This article focuses on the considerations that customers should plan for before they deploy applications in the Azure public MEC.

-## Prerequisites

-## Best practices

-For Azure public MEC, follow these best practices:

-## Azure public MEC architecture

-Deploy application components that require low latencies in the Azure public MEC, and components that are non-latency sensitive in the Azure region. For more information, see [Azure public multi-access edge compute deployment](/azure/architecture/example-scenario/hybrid/public-multi-access-edge-compute-deployment).

-### Azure region

-The Azure region should run the components of the application that perform control and management plane functions and aren't latency sensitive.

-The following sections show some examples.

-#### Azure database and storage

-#### AI and Analytics

-#### Identity services

-#### Secrets management

-### Azure public MEC

-Azure public MEC should run components that are latency sensitive and need faster response times from compute resources. To do so, run your application on compute services such as Azure Virtual Machines and Azure Kubernetes Service in the public MEC.

-## Availability and resiliency

-Applications you deploy in the Azure public MEC can be made available and resilient by using the following methods:

- - Actively replicates VMs from the Azure public MEC to the parent region and makes them available to fail over and fail back if there's an outage.

- - Backs up VMs to prevent data corruption or lost data.

- > [!NOTE]

- > The Azure backup and disaster recovery solution for Azure public MEC supports only Azure Virtual Machines.

-A trade-off exists between availability and latency. Although failing over the application from the Azure public MEC to the Azure region ensures that the application is available, it might increase the latency to the application.

-Architect your edge applications by utilizing the Azure Region for the components that are less latency sensitive, need to be persistent or need to be shared between public MEC sites. This will allow for the applications to be more resilient and cost effective. The public MEC can host the latency sensitive components.

-## Data residency

-> [!IMPORTANT]

-Azure public MEC doesn't store or process customer data outside the region you deploy the service instance in.

-## Next steps

-To deploy a virtual machine in Azure public MEC using an Azure Resource Manager (ARM) template, advance to the following article:

-> [!div class="nextstepaction"]

-> [Quickstart: Deploy a virtual machine in Azure public MEC using an ARM template](quickstart-create-vm-azure-resource-manager-template.md)

-description: Learn about important concepts for Azure public multi-access edge compute (MEC).

-# Key concepts for Azure public MEC

-This document describes important concepts for Azure public multi-access edge compute (MEC).

-## ExtendedLocation field

-All resource providers provide an additional field named [extendedLocation](/javascript/api/@azure/arm-compute/extendedlocation), which you use to deploy resources in the Azure public MEC.

-## Azure Edge Zone ID

-Every Azure public MEC site has an Azure Edge Zone ID. This ID is one of the attributes that the `extendedLocation` field uses to differentiate sites.

-## Azure CLI and SDKs

-To support Azure public MEC, Microsoft has updated the Azure services SDKs. For information about how to use these SDKs for deployment, see:

-## ARM templates

-You can use Azure Resource Manager (ARM) templates to deploy resources in the Azure public MEC. Here's an example of how to use `extendedLocation` in an ARM template to deploy a virtual machine (VM):

-```json

-{

- ...

- "type": "Microsoft.Compute/virtualMachines"

- "extendedLocation": {

- "type": "EdgeZone",

- "name": <edgezoneid>,

- }

- ...

-}

-```

-## Parent Azure regions

-Every Azure public MEC site is associated with a parent Azure region. This region hosts all the control plane functions associated with the services running in the Azure public MEC. The following table lists active Azure public MEC sites, along with their Edge Zone ID and associated parent region:

-| Telco provider | Azure public MEC name | Edge Zone ID | Parent region |

-| -- | | | - |

-| AT&T | ATT Atlanta A | attatlanta1 | East US 2 |

-| AT&T | ATT Dallas A | attdallas1 | South Central US |

-| AT&T | ATT Detroit A | attdetroit1 | Central US |

-## Azure services

-### Azure Virtual Machines

-Azure public MEC supports specific compute and GPU VM SKUs. The following table lists the supported VM sizes:

-| Type | Series | VM size |

-| - | | - |

-| VM | D-series | Standard_DS1_v2, Standard_DS2_v2, Standard_D2s_v3, Standard_D4s_v3, Standard_D8s_v3 |

-| VM | E-series | Standard_E4s_v3, Standard_E8s_v3 |

-| GPU | NCasT4_v3-series | Standard_NC4asT4_v3, Standard_NC8asT4_v3 |

-### Public IP

-Azure public MEC allows users to create Azure public IPs that you can then associate with resources such as Azure Virtual Machines, Azure Standard Load Balancer, and Azure Kubernetes Clusters. All the Azure public MEC IPs are Standard SKU public IPs.

-### Azure Bastion

-Azure Bastion is a service you deploy that lets you connect to a VM by using your browser and the Azure portal. To access a VM deployed in the Azure public MEC, the Bastion host must be deployed in a virtual network (VNet) in the parent Azure region of the Azure public MEC site.

-### Azure Load Balancer

-The Azure public MEC supports the Azure Standard Load Balancer SKU.

-### Network security groups

-Azure network security groups that are associated with resources created in the Azure public MEC should be created in the parent Azure region.

-### Resource groups

-Resource groups that are associated with resources created in the Azure public MEC should be created in the parent Azure region.

-### Azure Storage services

-Azure public MEC supports creating Standard SSD managed disks only. All other Azure Storage services aren't supported in the public MEC.

-### Default outbound access

-Because Azure public MEC doesn't support [default outbound access](../virtual-network/ip-services/default-outbound-access.md), manage your outbound connectivity by using one of the following methods:

-### DNS Resolution

-By default, all services running in the Azure public MEC use the DNS infrastructure in the parent Azure region.

-## Next steps

-To learn about considerations for deployment in the Azure public MEC, advance to the following article:

-> [!div class="nextstepaction"]

-> [Considerations for deployment in the Azure public MEC](considerations-for-deployment.md)

-description: Learn about the benefits of Azure public multi-access edge compute (MEC) and how it works.

-# What is Azure public MEC?

-Azure public multi-access edge compute (MEC) sites are small-footprint extensions of Azure. They're placed in or near mobile operators' data centers in metro areas, and are designed to run workloads that require low latency while being attached to the mobile network. Azure public MEC is offered in partnership with the operators. The placement of the infrastructure offers lower latency for applications that are accessed from mobile devices connected to the 5G mobile network.

-Azure public MEC provides secure, reliable, high-bandwidth connectivity between applications that run close to the user while being served by the Microsoft global network. Azure public MEC offers a set of Azure services like Azure Virtual Machines, Azure Load Balancer, and Azure Kubernetes for Edge, with the ability to leverage and connect to other Azure services available in the Azure region.

-Some of the industries and use cases where Azure public MEC can provide benefits are:

-## Benefits of Azure public MEC

-Azure public MEC has the following benefits:

-

- - Enterprises and developers can run low-latency applications by using the operatorΓÇÖs public 5G network connectivity. This connectivity is architected with a direct, dedicated, and optimized connection to the operatorΓÇÖs mobility core network.

- - Azure-managed toolset: Azure customers can provision and manage their Azure public MEC services and workloads through the Azure portal and other essential Azure tools.

- - Consistent developer experience: Developing and building applications for the public MEC utilizes the same array of features and tools that Azure uses.

- - ISVs working on optimized and scalable applications for edge computing can use the Azure public MEC solution for building solutions. These solutions offer low latency and leverage the 5G mobility network and connected scenarios.

-## Service offerings for Azure public MEC

-Azure public MEC enables some key Azure services for customers to deploy. The control plane for these services remains in the region and the data plane is deployed at the edge, resulting in a smaller Azure footprint, fewer dependencies, and the ability to leverage other services deployed at the region.

-The following key services are available in Azure public MEC:

-The following diagram shows how services are deployed at the Azure public MEC location. With this capability, enterprises and developers can deploy the customer workloads closer to their users.

-## Partnership with operators

-Azure public MEC solutions are available in partnership with mobile network operators. The current operator partnerships are as follows:

-## Next steps

-To learn about important concepts for Azure public MEC, advance to the following article:

-> [!div class="nextstepaction"]

-> [Key concepts for Azure public MEC](key-concepts.md)

-description: This article lists all the Partner solutions that can be deployed in Public MEC.

-# Partner solutions for Public MEC

-## List of Partner solutions that can be deployed in Azure public MEC

-The table in this article provides information on Partner solutions that can be deployed in Public MEC.

->

->

-| **Vendor** | **Product(s) Name** | **Market Place** |

-| | | |

-| **Checkpoint** | [CloudGuard Network Security](https://www.checkpoint.com/cloudguard/cloud-network-security/) | [CloudGuard Network Security](https://azuremarketplace.microsoft.com/marketplace/apps/checkpoint.vsec?tab=Overview) |

-| **Citrix** | [Application Delivery Controller](https://www.citrix.com/products/citrix-adc/) | [Citrix ADC](https://azuremarketplace.microsoft.com/marketplace/apps/citrix.netscalervpx-1vm-3nic?tab=Overview) |

-| **Couchbase** | [Server](https://www.couchbase.com/products/server), [Sync-Gateway](https://www.couchbase.com/products/sync-gateway) | [Couchbase Server Enterprise](https://azuremarketplace.microsoft.com/en/marketplace/apps/couchbase.couchbase-enterprise?tab=Overview) [Couchbase Sync Gateway Enterprise](https://azuremarketplace.microsoft.com/en/marketplace/apps/couchbase.couchbase-sync-gateway-enterprise?tab=Overview) |

-| **Fortinet** | [FortiGate](https://www.fortinet.com/products/private-cloud-security/fortigate-virtual-appliances) |[FortiGate](https://azuremarketplace.microsoft.com/marketplace/apps/fortinet.fortinet-fortigate?tab=Overview) |

-| **Fortinet** | [FortiWeb](https://www.fortinet.com/products/web-application-firewall/fortiweb?tab=saas) | [FortiWeb](https://azuremarketplace.microsoft.com/marketplace/apps/fortinet.fortinet_waas?tab=Overview) |

-| **Multicasting.io** | [Multicasting](https://multicasting.io/) | |

-| **Net Foundry** | [Zero Trust Edge Fabric for Azure MEC](https://netfoundry.io/zero-trust-edge-fabric-azure-public-mec/) | [NetFoundry Edge Router](https://azuremarketplace.microsoft.com/marketplace/apps/netfoundryinc.ziti-edge-router?tab=Overview) |

-| **Palo Alto Networks** | [VM-Series](https://docs.paloaltonetworks.com/vm-series/9-1/vm-series-performance-capacity/vm-series-performance-capacity/vm-series-on-azure-models-and-vms) | [VM-Series Next-Generation Firewall](https://ms.portal.azure.com/#view/Microsoft_Azure_Marketplace/GalleryItemDetailsBladeNopdl/id/paloaltonetworks.vmseries-ngfw/product/%7B%22displayName%22%3A%22VM-Series%20Next-Generation%20Firewall%20from%20Palo%20Alto%20Networks%22%2C%22itemDisplayName%22%3A%22VM-Series%20Next-Generation%20Firewall%20from%20Palo%20Alto%20Networks%22%2C%22id%22%3A%22paloaltonetworks.vmseries-ngfw%22%2C%22bigId%22%3A%22DZH318Z0BP7N%22%2C%22legacyId%22%3A%22paloaltonetworks.vmseries-ngfw%22%2C%22offerId%22%3A%22vmseries-ngfw%22%2C%22publisherId%22%3A%22paloaltonetworks%22%2C%22publisherDisplayName%22%3A%22Palo%20Alto%20Networks%2C%20Inc.%22%2C%22summary%22%3A%22Looking%20to%20secure%20your%20applications%20in%20Azure%2C%20protect%20against%20threats%20and%20prevent%20data%20exfiltration%3F%22%2C%22longSummary%22%3A%22VM-Series%20next-generation%20firewall%20is%20for%20developers%2C%20architects%2C%20and%20security%20teams.%20Enable%20firewall%2C%20inline%20threat%2C%20and%20data%20theft%20preventions%20into%20your%20application%20development%20workflows%20using%20native%20Azure%20services%20and%20VM-Series%20automation%20features.%22%2C%22description%22%3A%22%3Cp%3EThe%20VM-Series%20virtualized%20next-generation%20firewall%20allows%20developers%2C%20and%20cloud%20security%20architects%20to%20automate%20and%20deploy%20inline%20firewall%20and%20threat%20prevention%20along%20with%20their%20application%20deployment%20workflows.%20Users%20can%20achieve%20%E2%80%98touchless%E2%80%99%20deployment%20of%20advanced%20firewall%2C%20threat%20prevention%20capabilities%20using%20ARM%20templates%2C%20native%20Azure%20services%2C%20and%20VM-Series%20firewall%20automation%20features%20such%20as%20bootstrapping.%20Auto-scaling%20using%20Azure%20VMSS%20and%20tag-based%20dynamic%20security%20policies%20are%20supported%20using%20the%20Panorama%20Plugin%20for%20Azure.%3C%2Fp%3E%20%5Cn%5Cn%3Cp%3EProtect%20your%20applications%20and%20data%20with%20whitelisting%20and%20segmentation%20policies.%20Policies%20update%20dynamically%20based%20on%20Azure%20tags%20assigned%20to%20application%20VMs%2C%20allowing%20you%20to%20re) |

-| **Spirent** | [Spirent](https://www.spirent.com/solutions/edge-computing-validating-services) | [Spirent for Azure public MEC](https://azuremarketplace.microsoft.com/marketplace/apps/spirentcommunications1641943316121.umetrix-mec?tab=Overview) |

-| **Summit Tech** | [Odience](https://odience.com/interactions) | |

-| **Veeam** | [Veeam Backup & Replication](https://www.veeam.com/kb4375)| [Veeam Backup & Replication](https://azuremarketplace.microsoft.com/marketplace/apps/veeam.veeam-backup-replication?tab=Overview) |

-| **VMware** | [SDWAN Edge](https://sase.vmware.com/products/component-network-edge)| [VMware SD-WAN - Virtual Edge](https://azuremarketplace.microsoft.com/marketplace/apps/vmware-inc.sol-42222-bbj?tab=Overview) |

-| | | |

-Currently, the solutions can be deployed at the following locations:

-| **MEC Location** | **Extended Location** |

-| | |

-| AT&T Atlanta | attatlanta1 |

-| AT&T Dallas | attdallas1 |

-| AT&T Detroit | attdetroit1 |

-## Next steps

-* For more information about Public MEC, see the [Overview](Overview.md).

-description: In this quickstart, learn how to deploy a virtual machine in Azure public multi-access edge compute (MEC) by using an Azure Resource Manager template.

-# Quickstart: Deploy a virtual machine in Azure public MEC using an ARM template

-In this quickstart, you learn how to use an Azure Resource Manager (ARM) template to deploy an Ubuntu Linux virtual machine (VM) in Azure public multi-access edge compute (MEC).

-## Prerequisites

- > [!NOTE]

- > Azure public MEC deployments are supported in Azure CLI versions 2.26 and later.

-## Review the template

-1. Review the following example ARM template.

- Every resource you deploy in Azure public MEC has an extra attribute named `extendedLocation`, which Azure adds to the resource provider. The example ARM template deploys these resources:

- - Virtual network

- - Public IP address

- - Network interface

- - Network security group

- - Virtual machine

- In this example ARM template:

- - The Azure Edge Zone ID is different from the display name of the Azure public MEC.

- - The Azure network security group has an inbound rule that allows SSH and HTTPS access from everywhere.

- ```json

- {

- "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",

- "contentVersion": "1.0.0.0",

- "parameters": {

- "adminUsername": {

- "type": "String",

- "metadata": {

- "description": "Username for the Virtual Machine."

- }

- },

- "adminPassword": {

- "type": "SecureString",

- "metadata": {

- "description": "Password for the Virtual Machine."

- }

- },

- "dnsLabelPrefix": {

- "type": "String",

- "metadata": {

- "description": "Unique DNS Name for the Public IP used to access the Virtual Machine."

- }

- },

- "vmSize": {

- "defaultValue": "Standard_D2s_v3",

- "type": "String",

- "metadata": {

- "description": "Size of the virtual machine."

- }

- },

- "location": {

- "defaultValue": "[resourceGroup().location]",

- "type": "String",

- "metadata": {

- "description": "Location for all resources."

- }

- },

- "EdgeZone": {

- "type": "String"

- },

- "publisher": {

- "type": "string",

- "defaultValue": "Canonical",

- "metadata" : {

- "description": "Publisher for the VM Image"

- }

- },

- "offer": {

- "type": "string",

- "defaultValue": "UbuntuServer",

- "metadata" : {

- "description": "Offer for the VM Image"

- }

- },

- "sku": {

- "type": "string",

- "defaultValue": "18.04-LTS",

- "metadata" : {

- "description": "SKU for the VM Image"

- }

- },

- "osVersion": {

- "type": "string",

- "defaultValue": "latest",

- "metadata" : {

- "description": "version for the VM Image"

- }

- },

- "vmName": {

- "defaultValue": "myEdgeVM",

- "type": "String",

- "metadata": {

- "description": "VM Name."

- }

- }

- },

- "variables": {

- "nicName": "myEdgeVMNic",

- "addressPrefix": "10.0.0.0/16",

- "subnetName": "Subnet",

- "subnetPrefix": "10.0.0.0/24",

- "publicIPAddressName": "myEdgePublicIP",

- "virtualNetworkName": "MyEdgeVNET",

- "subnetRef": "[resourceId('Microsoft.Network/virtualNetworks/subnets', variables('virtualNetworkName'), variables('subnetName'))]",

- "networkSecurityGroupName": "default-NSG"

- },

- "resources": [

- {

- "type": "Microsoft.Network/publicIPAddresses",

- "apiVersion": "2018-11-01",

- "name": "[variables('publicIPAddressName')]",

- "location": "[parameters('location')]",

- "extendedLocation": {

- "type": "EdgeZone",

- "name": "[parameters('EdgeZone')]"

- },

- "sku": {

- "name": "Standard"

- },

- "properties": {

- "publicIPAllocationMethod": "Static",

- "dnsSettings": {

- "domainNameLabel": "[parameters('dnsLabelPrefix')]"

- }

- }

- },

- {

- "type": "Microsoft.Network/networkSecurityGroups",

- "apiVersion": "2019-08-01",

- "name": "[variables('networkSecurityGroupName')]",

- "location": "[parameters('location')]",

- "properties": {

- "securityRules": [

- {

- "name": "AllowHttps",

- "properties": {

- "description": "HTTPS is allowed",

- "protocol": "*",

- "sourcePortRange": "*",

- "destinationPortRange": "443",

- "sourceAddressPrefix": "*",

- "destinationAddressPrefix": "*",

- "access": "Allow",

- "priority": 130,

- "direction": "Inbound",

- "sourcePortRanges": [],

- "destinationPortRanges": [],

- "sourceAddressPrefixes": [],

- "destinationAddressPrefixes": []

- }

- },

- {

- "name": "AllowSSH",

- "properties": {

- "description": "HTTPS is allowed",

- "protocol": "*",

- "sourcePortRange": "*",

- "destinationPortRange": "22",

- "sourceAddressPrefix": "*",

- "destinationAddressPrefix": "*",

- "access": "Allow",

- "priority": 140,

- "direction": "Inbound",

- "sourcePortRanges": [],

- "destinationPortRanges": [],

- "sourceAddressPrefixes": [],

- "destinationAddressPrefixes": []

- }

- }

- ]

- }

- },

- {

- "type": "Microsoft.Network/virtualNetworks",

- "apiVersion": "2018-11-01",

- "name": "[variables('virtualNetworkName')]",

- "location": "[parameters('location')]",

- "extendedLocation": {

- "type": "EdgeZone",

- "name": "[parameters('EdgeZone')]"

- },

- "dependsOn": [

- "[resourceId('Microsoft.Network/networkSecurityGroups', variables('networkSecurityGroupName'))]"

- ],

- "properties": {

- "addressSpace": {

- "addressPrefixes": [

- "[variables('addressPrefix')]"

- ]

- },

- "subnets": [

- {

- "name": "[variables('subnetName')]",

- "properties": {

- "addressPrefix": "[variables('subnetPrefix')]",

- "networkSecurityGroup": {

- "id": "[resourceId('Microsoft.Network/networkSecurityGroups', variables('networkSecurityGroupName'))]"

- }

- }

- }

- ]

- }

- },

- {

- "type": "Microsoft.Network/networkInterfaces",

- "apiVersion": "2018-11-01",

- "name": "[variables('nicName')]",

- "location": "[parameters('location')]",

- "extendedLocation": {

- "type": "EdgeZone",

- "name": "[parameters('EdgeZone')]"

- },

- "dependsOn": [

- "[resourceId('Microsoft.Network/publicIPAddresses/', variables('publicIPAddressName'))]",

- "[resourceId('Microsoft.Network/virtualNetworks/', variables('virtualNetworkName'))]"

- ],

- "properties": {

- "ipConfigurations": [

- {

- "name": "ipconfig1",

- "properties": {

- "privateIPAllocationMethod": "Dynamic",

- "publicIPAddress": {

- "id": "[resourceId('Microsoft.Network/publicIPAddresses',variables('publicIPAddressName'))]"

- },

- "subnet": {

- "id": "[variables('subnetRef')]"

- }

- }

- }

- ]

- }

- },

- {

- "type": "Microsoft.Compute/virtualMachines",

- "apiVersion": "2020-06-01",

- "name": "[parameters('vmName')]",

- "location": "[parameters('location')]",

- "extendedLocation": {

- "type": "EdgeZone",

- "name": "[parameters('EdgeZone')]"

- },

- "dependsOn": [

- "[resourceId('Microsoft.Network/networkInterfaces/', variables('nicName'))]"

- ],

- "properties": {

- "hardwareProfile": {

- "vmSize": "[parameters('vmSize')]"

- },

- "osProfile": {

- "computerName": "[parameters('vmName')]",

- "adminUsername": "[parameters('adminUsername')]",

- "adminPassword": "[parameters('adminPassword')]"

- },

- "storageProfile": {

- "imageReference": {

- "publisher": "[parameters('publisher')]",

- "offer": "[parameters('offer')]",

- "sku": "[parameters('sku')]",

- "version": "[parameters('osVersion')]"

- },

- "osDisk": {

- "createOption": "FromImage",

- "managedDisk": {

- "storageAccountType": "StandardSSD_LRS"

- }

- }

- },

- "networkProfile": {

- "networkInterfaces": [

- {

- "id": "[resourceId('Microsoft.Network/networkInterfaces',variables('nicName'))]"

- }

- ]

- }

- }

- }

- ],

- "outputs": {

- "hostname": {

- "type": "String",

- "value": "[reference(variables('publicIPAddressName')).dnsSettings.fqdn]"

- },

- "sshCommand": {

- "type": "string",

- "value": "[format('ssh {0}@{1}', parameters('adminUsername'), reference(resourceId('Microsoft.Network/publicIPAddresses', variables('publicIPAddressName'))).dnsSettings.fqdn)]"

- }

- }

- }

- ```

-## Deploy the ARM template using the Azure CLI

-1. Save the contents of the sample ARM template from the previous section in a file named *azurepublicmecDeploy.json*.

-1. Sign in to Azure with [az login](/cli/azure/reference-index#az-login) and set the Azure subscription with [az account set](/cli/azure/account#az-account-set) command.

- ```azurecli

- az login

- az account set --subscription <subscription name>

- ```

-1. Create an Azure resource group with the [az group create](/cli/azure/group#az-group-create) command. A resource group is a logical container into which Azure resources are deployed and managed. The following example creates a resource group named myResourceGroup:

- ```azurecli

- az group create --name myResourceGroup --location <location>

- ```

- > [!NOTE]

- > Each Azure public MEC site is associated with an Azure region. Based on the Azure public MEC location where the resource needs to be deployed, select the appropriate region value for the `--location` parameter. For more information, see [Key concepts for Azure public MEC](key-concepts.md).

-1. Deploy the ARM template in the resource group with the [az deployment group create](/cli/azure/deployment/group#az-deployment-group-create) command.

- ```azurecli

- az deployment group create --resource-group myResourceGroup --template-file azurepublicmecDeploy.json

- ```

- ```output

- Please provide string value for 'adminUsername' (? for help): <username>

- Please provide securestring value for 'adminPassword' (? for help): <password>

- Please provide string value for 'dnsLabelPrefix' (? for help): <uniqueDnsLabel>

- Please provide string value for 'EdgeZone' (? for help): <edge zone ID>

- ```

-1. Wait a few minutes for the deployment to run.

- After the command execution is complete, you can see the new resources in the myResourceGroup resource group. Here's a sample output:

- ```output

- {

- "id": "/subscriptions/xxxxxxx/resourceGroups/myResourceGroup/providers/Microsoft.Resources/deployments/edgeZonesDeploy",

- "location": null,

- "name": "edgeZonesDeploy",

- "properties": {

- "correlationId": "<xxxxxxxx>",

- "debugSetting": null,

- "dependencies": [

- {

- "dependsOn": [

- {

- "id": "/subscriptions/xxxxx/resourceGroups/myResourceGroup /providers/Microsoft.Network/networkSecurityGroups/default-NSG",

- "resourceGroup": " myResourceGroup ",

- "resourceName": "default-NSG",

- "resourceType": "Microsoft.Network/networkSecurityGroups"

- }

- ],

- "id": "/subscriptions/xxxxxx/resourceGroups/ myResourceGroup /providers/Microsoft.Network/virtualNetworks/MyEdgeTestVnet",

- "resourceGroup": " myResourceGroup ",

- "resourceName": " MyEdgeTestVnet ",

- "resourceType": "Microsoft.Network/virtualNetworks"

- },

- "outputs": {

- "hostname": {

- "type": "String",

- "value": "xxxxx.cloudapp.azure.com"

- },

- "sshCommand": {

- "type": "String",

- "value": "ssh <adminUsername>@<publicIPFQDN>"

- }

- },

- ...

- }

- ```

-## Access the virtual machine

-To use SSH to connect to the virtual machine in the Azure public MEC, the best method is to deploy a jump box in an Azure parent region.

-1. Follow the instructions in [Create a virtual machine in a region](/azure/virtual-machines/linux/quick-create-template).

-1. Use SSH to connect to the jump box virtual machine deployed in the region.

- ```bash

- ssh <username>@<regionVM_publicIP>

- ```

-1. From the jump box, use SSH to connect to the virtual machine created in the Azure public MEC.

- ```bash

- ssh <username>@<edgezoneVM_publicIP>

- ```

-## Clean up resources

-In this quickstart, you deployed an ARM template in Azure public MEC by using the Azure CLI. If you don't expect to need these resources in the future, use the [az group delete](/cli/azure/group#az-group-delete) command to remove the resource group, scale set, and all related resources. Using the `--yes` parameter deletes the resources without a confirmation prompt.

-```azurecli

-az group delete \--name myResourceGroup \--yes

-```

-## Next steps

-To deploy a virtual machine in Azure public MEC using Azure CLI, advance to the following article:

-> [!div class="nextstepaction"]

-> [Quickstart: Deploy a virtual machine in Azure public MEC using Azure CLI](quickstart-create-vm-cli.md)

-description: In this quickstart, learn how to deploy a virtual machine in Azure public multi-access edge (MEC) compute by using the Azure CLI.

-# Quickstart: Deploy a virtual machine in Azure public MEC using Azure CLI

-In this quickstart, you learn how to use Azure CLI to deploy a Linux virtual machine (VM) in Azure public multi-access edge compute (MEC).

-## Prerequisites

- > [!NOTE]

- > Azure public MEC deployments are supported in Azure CLI versions 2.26 and later.

-## Sign in to Azure and set your subscription

-1. Sign in to Azure by using the [az login](/cli/azure/reference-index#az-login) command.

- ```azurecli

- az login

- ```

-1. Set your Azure subscription with the [az account set](/cli/azure/account#az-account-set) command.

- ```azurecli

- az account set --subscription <subscription name>

- ```

-## Create a resource group

-1. Create an Azure resource group with the [az group create](/cli/azure/group#az-group-create) command. A resource group is a logical container into which Azure resources are deployed and managed. The following example creates a resource group named myResourceGroup.

- ```azurecli

- az group create --name myResourceGroup --location <location>

- ```

- > [!NOTE]

- > Each Azure public MEC site is associated with an Azure region. Based on the Azure public MEC location where the resource needs to be deployed, select the appropriate region value for the `--location` parameter. For more information, see [Key concepts for Azure public MEC](key-concepts.md).

-## Create a VM

-1. Create a VM with the [az vm create](/cli/azure/vm#az-vm-create) command.

- The following example creates a VM named myVMEdge and adds a user account named azureuser at Azure public MEC:

- ```azurecli

- az vm create \--resource-group myResourceGroup \--name myVMEdge \--image Ubuntu2204 \--admin-username azureuser \--admin-password <password> \--edge-zone <edgezone ID> \--public-ip-sku Standard

- ```

- The `--edge-zone` parameter determines the Azure public MEC location where the VM and its associated resources are created. Because Azure public MEC supports only standard SKU for a public IP, you must specify `Standard` for the `--public-ip-sku` parameter.

-1. Wait a few minutes for the VM and supporting resources to be created.

- The following example output shows a successful operation:

- ```output

- {

- "fqdns": "",

- "id": "/subscriptions/<id> /resourceGroups/myResourceGroup/providers/Microsoft.Compute/ virtualMachines/myVMEdge",

- "location": "<region>",

- "macAddress": "<mac_address>",

- "powerState": "VM running",

- "privateIpAddress": "10.0.0.4",

- "publicIpAddress": "<public_ip_address>",

- "resourceGroup": "myResourceGroup",

- "zones": ""

- }

- ```

-1. Note your `publicIpAddress` value in the output from your myVMEdge VM. Use this address to access the VM in the next sections.

-## Create a jump server in the associated region

-To use SSH to connect to the VM in Azure public MEC, the best method is to deploy a jump box in the same Azure region where you created your resource group.

-1. Create an Azure Virtual Network (VNet) by using the [az network vnet](/cli/azure/network/vnet) command.

- The following example creates a VNet named MyVnetRegion:

- ```azurecli

- az network vnet create --resource-group myResourceGroup --name MyVnetRegion --address-prefix 10.1.0.0/16 --subnet-name MySubnetRegion --subnet-prefix 10.1.0.0/24

- ```

-1. Create a VM to be deployed in the region with the [az vm create](/cli/azure/vm#az-vm-create) command.

- The following example creates a VM named myVMRegion in the region:

- ```azurecli

- az vm create --resource-group myResourceGroup --name myVMRegion --image Ubuntu2204 --admin-username azureuser --admin-password <password> --vnet-name MyVnetRegion --subnet MySubnetRegion --public-ip-sku Standard

- ```

-1. Note your `publicIpAddress` value in the output from the myVMregion VM. Use this address to access the VM in the next sections.

-## Accessing the VMs

-1. Use SSH to connect to the jump box VM deployed in the region. Use the IP address from the myVMRegion VM you created in the previous section.

- ```bash

- ssh azureuser@<regionVM_publicIP>

- ```

-1. From the jump box, use SSH to connect to the VM you created in Azure public MEC. Use the IP address from the myVMEdge VM you created in the previous section.

- ```bash

- ssh azureuser@<edgeVM_publicIP>

- ```

-1. Ensure the Azure network security groups allow port 22 access to the VMs you create.

-## Clean up resources

-In this quickstart, you deployed a VM in Azure public MEC by using the Azure CLI. If you don't expect to need these resources in the future, use the [az group delete](/cli/azure/group#az-group-delete) command to remove the resource group, VM, and all related resources. Using the `--yes` parameter deletes the resources without a confirmation prompt.

-```azurecli

-az group delete \--name myResourceGroup \--yes

-```

-## Next steps

-To deploy resources in Azure public MEC using the Go SDK, advance to the following article:

-> [!div class="nextstepaction"]

-> [Tutorial: Deploy resources in Azure public MEC using the Go SDK](tutorial-create-vm-using-go-sdk.md)

-description: In this tutorial, learn how to deploy resources in Azure public multi-access edge compute (MEC) by using the Go SDK.

-# Tutorial: Deploy resources in Azure public MEC using the Go SDK

-In this tutorial, you learn how to use the Go SDK to deploy resources in Azure public multi-access edge compute (MEC). The tutorial provides code snippets written in Go to deploy a virtual machine and public IP resources in an Azure public MEC solution. You can use the same model and template to deploy other resources and services that are supported for Azure public MEC. This article isnΓÇÖt intended to be a tutorial on Go; it focuses only on the API calls required to deploy resources in Azure public MEC.

-For more information about Go, see [Azure for Go developers](/azure/developer/go/). For Go samples, see [Azure Go SDK samples](https://github.com/azure-samples/azure-sdk-for-go-samples).

-In this tutorial, you learn how to:

-> [!div class="checklist"]

->

-> - Create a virtual machine

-> - Create a public IP address

-> - Deploy a virtual network and public IP address

-## Prerequisites

-### Install Go

-You can download and install the latest version of [Go](https://go.dev/doc/install). It will replace the existing Go on your machine. If you want to install multiple Go versions on the same machine, see [Managing Go installations](https://go.dev/doc/manage-install).

-### Authentication

-You need to get authentication before you use any Azure service. You could either use Azure CLI to sign in or set authentication environment variables.

-#### Use Azure CLI to sign in

-You can use `az login` in the command line to sign in to Azure via your default browser. Detailed instructions can be found in [Sign in with Azure CLI](/cli/azure/authenticate-azure-cli).

-#### Set environment variables

-You need the following values to authenticate to Azure:

-Obtain these values from the portal by following these instructions:

- 1. Login into your Azure account

- 2. Select **Subscriptions** in the left sidebar

- 3. Select whichever subscription is needed

- 4. Select **Overview**

- 5. Copy the Subscription ID

- For information on how to get Client ID, Client Secret, and Tenant ID, see [Create a Microsoft Entra application and service principal that can access resources](/azure/active-directory/develop/howto-create-service-principal-portal).

- After you obtain the values, you need to set the following values as your environment variables:

- - `AZURE_CLIENT_ID`

- - `AZURE_CLIENT_SECRET`

- - `AZURE_TENANT_ID`

- - `AZURE_SUBSCRIPTION_ID`

- To set the following environment variables on your development system:

- **Windows** (Administrator access is required)

- 1. Open the Control Panel

- 2. Select **System Security** > **System**

- 3. Select **Advanced system settings** on the left

- 4. Inside the System Properties window, select the `Environment Variables…` button.

- 5. Select the property you would like to change, then select **Edit…**. If the property name is not listed, then select **New…**.

- **Linux-based OS** :

- ```export AZURE_CLIENT_ID="__CLIENT_ID__"

- export AZURE_CLIENT_SECRET="__CLIENT_SECRET__"

- export AZURE_TENANT_ID="__TENANT_ID__"

- export AZURE_SUBSCRIPTION_ID="__SUBSCRIPTION_ID__"````

-## Install the package

-The new SDK uses Go modules for versioning and dependency management.

-Run the following command to install the packages for this tutorial under your project folder:

-```sh

-go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v5

-go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v3

-go get github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources

-go get github.com/Azure/azure-sdk-for-go/sdk/azcore

-go get github.com/Azure/azure-sdk-for-go/sdk/azidentity

-```

-## Provision a virtual machine

-```go

-package main

-import (

- "context"

- "github.com/Azure/azure-sdk-for-go/sdk/azcore/to"

- "github.com/Azure/azure-sdk-for-go/sdk/azidentity"

- "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v5"

- "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v3"

- "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources"

- "log"

- "os"

-)

-func main() {

- subscriptionId := os.Getenv("AZURE_SUBSCRIPTION_ID")

- cred, err := azidentity.NewDefaultAzureCredential(nil)

- if err != nil {

- log.Fatalf("authentication failure: %+v", err)

- }

- // client factory

- resourcesClientFactory, err := armresources.NewClientFactory(subscriptionId, cred, nil)

- if err != nil {

- log.Fatalf("cannot create client factory: %+v", err)

- }

- computeClientFactory, err := armcompute.NewClientFactory(subscriptionId, cred, nil)

- if err != nil {

- log.Fatalf("cannot create client factory: %+v", err)

- }

- networkClientFactory, err := armnetwork.NewClientFactory(subscriptionId, cred, nil)

- if err != nil {

- log.Fatalf("cannot create client factory: %+v", err)

- }

- // Step 1: Provision a resource group

- _, err = resourcesClientFactory.NewResourceGroupsClient().CreateOrUpdate(

- context.Background(),

- "<resourceGroupName>",

- armresources.ResourceGroup{

- Location: to.Ptr("westus"),

- },

- nil,

- )

- if err != nil {

- log.Fatal("cannot create resources group:", err)

- }

- // Step 2: Provision a virtual network

- virtualNetworksClientCreateOrUpdateResponsePoller, err := networkClientFactory.NewVirtualNetworksClient().BeginCreateOrUpdate(

- context.Background(),

- "<resourceGroupName>",

- "<virtualNetworkName>",

- armnetwork.VirtualNetwork{

- Location: to.Ptr("westus"),

- ExtendedLocation: &armnetwork.ExtendedLocation{

- Name: to.Ptr("<edgezoneid>"),

- Type: to.Ptr(armnetwork.ExtendedLocationTypesEdgeZone),

- },

- Properties: &armnetwork.VirtualNetworkPropertiesFormat{

- AddressSpace: &armnetwork.AddressSpace{

- AddressPrefixes: []*string{

- to.Ptr("10.0.0.0/16"),

- },

- },

- Subnets: []*armnetwork.Subnet{

- {

- Name: to.Ptr("test-1"),

- Properties: &armnetwork.SubnetPropertiesFormat{

- AddressPrefix: to.Ptr("10.0.0.0/24"),

- },

- },

- },

- },

- },

- nil,

- )

- if err != nil {

- log.Fatal("network creation failed", err)

- }

- virtualNetworksClientCreateOrUpdateResponse, err := virtualNetworksClientCreateOrUpdateResponsePoller.PollUntilDone(context.Background(), nil)

- if err != nil {

- log.Fatal("cannot create virtual network:", err)

- }

- subnetID := *virtualNetworksClientCreateOrUpdateResponse.Properties.Subnets[0].ID

- // Step 3: Provision an IP address

- publicIPAddressesClientCreateOrUpdateResponsePoller, err := networkClientFactory.NewPublicIPAddressesClient().BeginCreateOrUpdate(

- context.Background(),

- "<resourceGroupName>",

- "<publicIPName>",

- armnetwork.PublicIPAddress{

- Name: to.Ptr("<publicIPName>"),

- Location: to.Ptr("westus"),

- ExtendedLocation: &armnetwork.ExtendedLocation{

- Name: to.Ptr("<edgezoneid>"),

- Type: to.Ptr(armnetwork.ExtendedLocationTypesEdgeZone),

- },

- SKU: &armnetwork.PublicIPAddressSKU{

- Name: to.Ptr(armnetwork.PublicIPAddressSKUNameStandard),

- },

- Properties: &armnetwork.PublicIPAddressPropertiesFormat{

- PublicIPAllocationMethod: to.Ptr(armnetwork.IPAllocationMethodStatic),

- },

- },

- nil,

- )

- if err != nil {

- log.Fatal("public ip creation failed", err)

- }

- publicIPAddressesClientCreateOrUpdateResponse, err := publicIPAddressesClientCreateOrUpdateResponsePoller.PollUntilDone(context.Background(), nil)

- if err != nil {

- log.Fatal("cannot create public ip: ", err)

- }

- // Step 4: Provision the network interface client

- interfacesClientCreateOrUpdateResponsePoller, err := networkClientFactory.NewInterfacesClient().BeginCreateOrUpdate(

- context.Background(),

- "<resourceGroupName>",

- "<networkInterfaceName>",

- armnetwork.Interface{

- Location: to.Ptr("westus"),

- ExtendedLocation: &armnetwork.ExtendedLocation{

- Name: to.Ptr("<edgezoneid>"),

- Type: to.Ptr(armnetwork.ExtendedLocationTypesEdgeZone),

- },

- Properties: &armnetwork.InterfacePropertiesFormat{

- EnableAcceleratedNetworking: to.Ptr(true),

- IPConfigurations: []*armnetwork.InterfaceIPConfiguration{

- {

- Name: to.Ptr("<ipConfigurationName>"),

- Properties: &armnetwork.InterfaceIPConfigurationPropertiesFormat{

- Subnet: &armnetwork.Subnet{

- ID: to.Ptr(subnetID),

- },

- PublicIPAddress: &armnetwork.PublicIPAddress{

- ID: publicIPAddressesClientCreateOrUpdateResponse.ID,

- },

- },

- },

- },

- },

- },

- nil,

- )

- if err != nil {

- log.Fatal("interface creation failed", err)

- }

- interfacesClientCreateOrUpdateResponse, err := interfacesClientCreateOrUpdateResponsePoller.PollUntilDone(context.Background(), nil)

- if err != nil {

- log.Fatal("cannot create interface:", err)

- }

- // Step 5: Provision the virtual machine

- virtualMachinesClientCreateOrUpdateResponsePoller, err := computeClientFactory.NewVirtualMachinesClient().BeginCreateOrUpdate(

- context.Background(),

- "<resourceGroupName>",

- "<vmName>",

- armcompute.VirtualMachine{

- Location: to.Ptr("westus"),

- ExtendedLocation: &armcompute.ExtendedLocation{

- Name: to.Ptr("<edgezoneid>"),

- Type: to.Ptr(armcompute.ExtendedLocationTypesEdgeZone),

- },

- Properties: &armcompute.VirtualMachineProperties{

- StorageProfile: &armcompute.StorageProfile{

- ImageReference: &armcompute.ImageReference{

- Publisher: to.Ptr("<publisher>"),

- Offer: to.Ptr("<offer>"),

- SKU: to.Ptr("<sku>"),

- Version: to.Ptr("<version>"),

- },

- },

- HardwareProfile: &armcompute.HardwareProfile{

- VMSize: to.Ptr(armcompute.VirtualMachineSizeTypesStandardD2SV3),

- },

- OSProfile: &armcompute.OSProfile{

- ComputerName: to.Ptr("<computerName>"),

- AdminUsername: to.Ptr("<adminUsername>"),

- AdminPassword: to.Ptr("<adminPassword>"),

- },

- NetworkProfile: &armcompute.NetworkProfile{

- NetworkInterfaces: []*armcompute.NetworkInterfaceReference{

- {

- ID: interfacesClientCreateOrUpdateResponse.ID,

- Properties: &armcompute.NetworkInterfaceReferenceProperties{

- Primary: to.Ptr(true),

- },

- },

- },

- },

- },

- },

- nil,

- )

- if err != nil {

- log.Fatal("virtual machine creation failed", err)

- }

- _, err = virtualMachinesClientCreateOrUpdateResponsePoller.PollUntilDone(context.Background(), nil)

- if err != nil {

- log.Fatal("cannot create virtual machine:", err)

- }

-}

-```

-## Clean up resources

-In this tutorial, you created a VM in Azure public MEC by using the Go SDK. If you don't expect to need these resources in the future, use the Azure portal to delete the resource group that you created.

-## Next steps

-To deploy a virtual machine in Azure public MEC using the Python SDK, advance to the following article:

-> [!div class="nextstepaction"]

-> [Tutorial: Deploy a virtual machine in Azure public MEC using the Python SDK](tutorial-create-vm-using-python-sdk.md)

-description: This tutorial demonstrates how to use Azure SDK management libraries in a Python script to create a resource group in Azure public multi-access edge compute (MEC) that contains a Linux virtual machine.

-# Tutorial: Deploy a virtual machine in Azure public MEC using the Python SDK

-In this tutorial, you use Python SDK to deploy resources in Azure public multi-access edge compute (MEC). The tutorial provides Python code to deploy a virtual machine (VM) and its dependencies in Azure public MEC.

-For information about Python SDKs, see [Azure libraries for Python usage patterns](/azure/developer/python/sdk/azure-sdk-library-usage-patterns).

-In this tutorial, you learn how to:

-> [!div class="checklist"]

->

-> - Install the required Azure library packages

-> - Provision a virtual machine

-> - Run the script in your development environment

-> - Create a jump server in the associated region

-> - Access the VMs

-## Prerequisites

-## Install the required Azure library packages

-1. Create a file named *requirements.txt* that lists the management libraries used in this example.

- ```txt

- azure-mgmt-resource

- azure-mgmt-compute

- azure-mgmt-network

- azure-identity

- azure-mgmt-extendedlocation==1.0.0b2

- ```

-1. Open a command prompt with the virtual environment activated and install the management libraries listed in requirements.txt.

- ```bash

- pip install -r requirements.txt

- ```

-## Provision a virtual machine

-1. Create a Python file named *provision_vm_edge.py* and populate it with the following Python script. The script deploys VM and its associated dependency in Azure public MEC. The comments in the script explain the details.

- ```Python

- # Import the needed credential and management objects from the libraries.

- from azure.identity import AzureCliCredential

- from azure.mgmt.resource import ResourceManagementClient

- from azure.mgmt.network import NetworkManagementClient

- from azure.mgmt.compute import ComputeManagementClient

- import os

- print(f"Provisioning a virtual machine...some operations might take a minute or two.")

- # Acquire a credential object using CLI-based authentication.

- credential = AzureCliCredential()

- # Retrieve subscription ID from environment variable.

- subscription_id = os.environ["AZURE_SUBSCRIPTION_ID"]

- # Step 1: Provision a resource group

- # Obtain the management object for resources, using the credentials from the CLI login.

- resource_client = ResourceManagementClient(credential, subscription_id)

-

- # Constants we need in multiple places: the resource group name, the region and the public mec location

- # in which we provision resources. Populate the variables with appropriate values.

- RESOURCE_GROUP_NAME = "PythonAzureExample-VM-rg"

- LOCATION = "<region>"

- PUBLIC_MEC_LOCATION = "<edgezone id>"

- USERNAME = "azureuser"

- PASSWORD = "<password>"

- # Provision the resource group.

- rg_result = resource_client.resource_groups.create_or_update(RESOURCE_GROUP_NAME,

- {

- "location": LOCATION

- }

- )

- print(f"Provisioned resource group {rg_result.name} in the {rg_result.location} region")

- # For details on the previous code, see Example: Use the Azure libraries to provision a resource group

- # at https://learn.microsoft.com/azure/developer/python/azure-sdk-example-resource-group

- # Step 2: Provision a virtual network

- # A virtual machine requires a network interface client (NIC). A NIC requires

- # a virtual network and subnet along with an IP address. Therefore, we must provision

- # these downstream components first, then provision the NIC, after which we

- # can provision the VM.

- # Network and IP address names

- VNET_NAME = "python-example-vnet-edge"

- SUBNET_NAME = "python-example-subnet-edge"

- IP_NAME = "python-example-ip-edge"

- IP_CONFIG_NAME = "python-example-ip-config-edge"

- NIC_NAME = "python-example-nic-edge"

- # Obtain the management object for networks

- network_client = NetworkManagementClient(credential, subscription_id)

- # Provision the virtual network and wait for completion

- poller = network_client.virtual_networks.begin_create_or_update(RESOURCE_GROUP_NAME,

- VNET_NAME,

- {

- "location": LOCATION,

- "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_LOCATION},

- "address_space": {

- "address_prefixes": ["10.1.0.0/16"]

- }

- }

- )

- vnet_result = poller.result()

- print(f"Provisioned virtual network {vnet_result.name} with address prefixes {vnet_result.address_space.address_prefixes}")

- # Step 3: Provision the subnet and wait for completion

- poller = network_client.subnets.begin_create_or_update(RESOURCE_GROUP_NAME,

- VNET_NAME, SUBNET_NAME,

- { "address_prefix": "10.1.0.0/24" }

- )

- subnet_result = poller.result()

- print(f"Provisioned virtual subnet {subnet_result.name} with address prefix {subnet_result.address_prefix}")

- # Step 4: Provision an IP address and wait for completion

- # Only the standard public IP SKU is supported at EdgeZones

- poller = network_client.public_ip_addresses.begin_create_or_update(RESOURCE_GROUP_NAME,

- IP_NAME,

- {

- "location": LOCATION,

- "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_LOCATION},

- "sku": { "name": "Standard" },

- "public_ip_allocation_method": "Static",

- "public_ip_address_version" : "IPV4"

- }

- )

- ip_address_result = poller.result()

- print(f"Provisioned public IP address {ip_address_result.name} with address {ip_address_result.ip_address}")

- # Step 5: Provision the network interface client

- poller = network_client.network_interfaces.begin_create_or_update(RESOURCE_GROUP_NAME,

- NIC_NAME,

- {

- "location": LOCATION,

- "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_LOCATION},

- "ip_configurations": [ {

- "name": IP_CONFIG_NAME,

- "subnet": { "id": subnet_result.id },

- "public_ip_address": {"id": ip_address_result.id }

- }]

- }

- )

- nic_result = poller.result()

- print(f"Provisioned network interface client {nic_result.name}")

- # Step 6: Provision the virtual machine

- # Obtain the management object for virtual machines

- compute_client = ComputeManagementClient(credential, subscription_id)

- VM_NAME = "ExampleVM-edge"

- print(f"Provisioning virtual machine {VM_NAME}; this operation might take a few minutes.")

- # Provision the VM specifying only minimal arguments, which defaults to an Ubuntu 18.04 VM

- # on a Standard DSv2-series with a public IP address and a default virtual network/subnet.

- poller = compute_client.virtual_machines.begin_create_or_update(RESOURCE_GROUP_NAME, VM_NAME,

- {

- "location": LOCATION,

- "extendedLocation": {"type": "EdgeZone", "name": PUBLIC_MEC_LOCATION},

- "storage_profile": {

- "image_reference": {

- "publisher": 'Canonical',

- "offer": "UbuntuServer",

- "sku": "18.04-LTS",

- "version": "latest"

- }

- },

- "hardware_profile": {

- "vm_size": "Standard_DS2_v2"

- },

- "os_profile": {

- "computer_name": VM_NAME,

- "admin_username": USERNAME,

- "admin_password": PASSWORD

- },

- "network_profile": {

- "network_interfaces": [{

- "id": nic_result.id,

- }]

- }

- }

- )

- vm_result = poller.result()

- print(f"Provisioned virtual machine {vm_result.name}")

- ```

-1. Before you run the script, populate these variables used in the step 1 section of the script:

- | Variable name | Description |

- | - | -- |

- | LOCATION | Azure region associated with the Azure public MEC location |

- | PUBLIC_MEC_LOCATION | Azure public MEC location identifier/edgezone ID |

- | PASSWORD | Password to use to sign in to the VM |

- > [!NOTE]

- > Each Azure public MEC site is associated with an Azure region. Based on the Azure public MEC location where the resource needs to be deployed, select the appropriate region value for the resource group to be created. For more information, see [Key concepts for Azure public MEC](key-concepts.md).

-## Run the script in your development environment

-1. Run the Python script you copied from the previous section.

- ```python

- python provision_vm_edge.py

- ```

-1. Wait a few minutes for the VM and supporting resources to be created.

- The following example output shows the VM create operation was successful.

- ```output

- (.venv) C:\Users >python provision_vm_edge.py

- Provisioning a virtual machine...some operations might take a minute or two.

- Provisioned resource group PythonAzureExample-VM-rg in the <region> region

- Provisioned virtual network python-example-vnet-edge with address prefixes ['10.1.0.0/16']

- Provisioned virtual subnet python-example-subnet-edge with address prefix 10.1.0.0/24

- Provisioned public IP address python-example-ip-edge with address <public ip>

- Provisioned network interface client python-example-nic-edge

- Provisioning virtual machine ExampleVM-edge; this operation might take a few minutes.

- Provisioned virtual machine ExampleVM-edge

- ```

-1. In the output from the python-example-ip-edge field, note your own publicIpAddress. Use this address to access the VM in the next section.

-## Create a jump server in the associated region

-To use SSH to connect to the VM in the Azure public MEC, the best method is to deploy a jump box in an Azure region where your resource group was deployed in the previous section.

-1. Follow the steps in [Use the Azure libraries to provision a virtual machine](/azure/developer/python/sdk/examples/azure-sdk-example-virtual-machines).

-1. Note your own publicIpAddress in the output from the python-example-ip field of the jump server VM. Use this address to access the VM in the next section.

-## Access the VMs

-1. Use SSH to connect to the jump box VM you deployed in the region with its IP address you noted previously.

- ```bash

- ssh azureuser@<python-example-ip>

- ```

-1. From the jump box, use SSH to connect to the VM you created in the Azure public MEC with its IP address you noted previously.

- ```bash

- ssh azureuser@<python-example-ip-edge>

- ```

-1. Ensure the Azure network security groups allow port 22 access to the VMs you create.

-## Clean up resources

-In this tutorial, you created a VM in Azure public MEC by using the Python SDK. If you don't expect to need these resources in the future, use the [az group delete](/cli/azure/group#az-group-delete) command to remove the resource group, scale set, and all related resources. Using the `--yes` parameter deletes the resources without a confirmation prompt.

-```azurecli

-az group delete --name PythonAzureExample-VM-rg --yes

-```

-## Next steps

-For questions about Azure public MEC, contact the product team:

-> [!div class="nextstepaction"]

-> [Azure public MEC product team](https://aka.ms/azurepublicmec)

-1. Create a document key field ("key": true). For blob content, the best candidates are metadata properties. Metadata properties often include characters, such as `/` and `-`, that are invalid for document keys. Because the indexer has a "base64EncodeKeys" property (true by default), it automatically encodes the metadata property, with no configuration or field mapping required.

- "base64EncodeKeys": null,

- Metadata properties often include characters, such as `/` and `-`, that are invalid for document keys. Because the indexer has a "base64EncodeKeys" property (true by default), it automatically encodes the metadata property, with no configuration or field mapping required.

- "base64EncodeKeys": null,

- Metadata properties often include characters, such as `/` and `-`, which are invalid for document keys. Because the indexer has a "base64EncodeKeys" property (true by default), it automatically encodes the metadata property, with no configuration or field mapping required.

- "base64EncodeKeys": null,

- "base64EncodeKeys": null,

- "base64EncodeKeys": null,

- "base64EncodeKeys" : null,

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-1. Configure the syslog daemon to export its vCenter log messages to a temporary text file so the AMA can collect them.

-[Back to list](#specific-instructions-per-application-type) | [Back to top](#custom-logs-via-ama-data-connectorconfigure-data-ingestion-to-microsoft-sentinel-from-specific-applications)

-| Instance details | Region | Required | Select the appropriate region for your storage account. For more information, see [Regions and Availability Zones in Azure](../../availability-zones/az-overview.md).<br /><br />Not all regions are supported for all types of storage accounts or redundancy configurations. For more information, see [Azure Storage redundancy](storage-redundancy.md).<br /><br />The choice of region can have a billing impact. For more information, see [Storage account billing](storage-account-overview.md#storage-account-billing).<br /><br />If your subscription supports Azure public multi-access edge zones (Azure MEC), you can deploy your storage account to an edge zone. For more information about edge zones, see [What is Azure public MEC?](../../public-multi-access-edge-compute-mec/overview.md). |