Merge pull request #273802 from MicrosoftDocs/main

4/30 11:00 AM IST Publish

Author: Saisang

articles/ai-services/speech-service/how-to-windows-voice-assistants-get-started.md

@@ -29,7 +29,7 @@ To start developing a voice assistant for Windows, you need to make sure
 Some resources necessary for a customized voice agent on Windows requires resources from Microsoft. The [UWP Voice Assistant Sample](windows-voice-assistants-faq.yml#the-uwp-voice-assistant-sample) provides sample versions of these resources for initial development and testing, so this section is unnecessary for initial development.
 
 - **Keyword model:** Voice activation requires a keyword model from Microsoft in the form of a .bin file. The .bin file provided in the UWP Voice Assistant Sample is trained on the keyword *Contoso*.
-- **Limited Access Feature Token:** Since the ConversationalAgent APIs provide access to microphone audio, they're protected under Limited Access Feature restrictions. To use a Limited Access Feature, you need to obtain a Limited Access Feature token connected to the package identity of your application from Microsoft. For more information about any Limited Access Feature or to request an unlock token, contact [Microsoft Support](https://github.com/MicrosoftDocs/azure-docs-pr).
+- **Limited Access Feature Token:** Since the ConversationalAgent APIs provide access to microphone audio, they're protected under Limited Access Feature restrictions. To use a Limited Access Feature, you need to obtain a Limited Access Feature token connected to the package identity of your application from Microsoft. For more information about any Limited Access Feature or to request an unlock token, contact [Microsoft Support](https://aka.ms/LAFAccessRequests).
 
 
 

articles/ai-services/translator/containers/transliterate-text-parameters.md

@@ -102,29 +102,13 @@ The following limitations apply:
 ]
 ```
 
-## Code samples: transliterate text
-
 > [!NOTE]
 >
 > * Each sample runs on the `localhost` that you specified with the `docker run` command.
 > * While your container is running, `localhost` points to the container itself.
 > * You don't have to use `localhost:5000`. You can use any port that is not already in use in your host environment.
 > To specify a port, use the `-p` option.
 
-### Transliterate with REST API
-
-```rest
-
-  POST https://api.cognitive.microsofttranslator.com/transliterate?api-version=3.0&language=ja&fromScript=Jpan&toScript=Latn HTTP/1.1
-  Ocp-Apim-Subscription-Key: ba6c4278a6c0412da1d8015ef9930d44
-  Content-Type:  application/json
-
-  [
-      {"Text":"こんにちは"},
-      {"Text":"さようなら"}
-  ]
-```
-
 ## Next Steps
 
 > [!div class="nextstepaction"]

articles/aks/load-balancer-standard.md

@@ -139,10 +139,6 @@ Two different pool membership types are available:
 * The AKS cluster must be version 1.23 or newer.
 * The AKS cluster must be using standard load balancers and virtual machine scale sets.
 
-#### Limitations
-
-* Clusters using IP based backend pools are limited to 2500 nodes.
-
 #### Create a new AKS cluster with IP-based inbound pool membership
 
 ```azurecli-interactive

articles/aks/media/supported-kubernetes-versions/kubernetes-versions-gantt.png

@@ -3,7 +3,7 @@ title: Use instance-level public IPs in Azure Kubernetes Service (AKS)
 description: Learn how to manage instance-level public IPs Azure Kubernetes Service (AKS)
 ms.topic: article
 ms.custom: devx-track-azurecli
-ms.date: 01/23/2024
+ms.date: 04/29/2024
 ms.author: pahealy
 author: phealy
 ---
@@ -71,50 +71,13 @@ You can locate the public IPs for your nodes in various ways:
 az vmss list-instance-public-ips -g MC_MyResourceGroup2_MyManagedCluster_eastus -n YourVirtualMachineScaleSetName
 ```
 
-## Use public IP tags on node public IPs (PREVIEW)
+## Use public IP tags on node public IPs
 
 Public IP tags can be utilized on node public IPs to utilize the [Azure Routing Preference](../virtual-network/ip-services/routing-preference-overview.md) feature.
 
-[!INCLUDE [preview features callout](includes/preview/preview-callout.md)]
-
 ### Requirements
 
 * AKS version 1.24 or greater is required.
-* Version 0.5.115 of the aks-preview extension is required.
-
-### Install the aks-preview Azure CLI extension
-
-To install the aks-preview extension, run the following command:
-
-```azurecli
-az extension add --name aks-preview
-```
-
-Run the following command to update to the latest version of the extension released:
-
-```azurecli
-az extension update --name aks-preview
-```
-
-### Register the 'NodePublicIPTagsPreview' feature flag
-
-Register the `NodePublicIPTagsPreview` feature flag by using the [`az feature register`][az-feature-register] command, as shown in the following example:
-
-```azurecli-interactive
-az feature register --namespace "Microsoft.ContainerService" --name "NodePublicIPTagsPreview"
-```
-
-It takes a few minutes for the status to show *Registered*. Verify the registration status by using the [`az feature show`][az-feature-show] command:
-
-```azurecli-interactive
-az feature show --namespace "Microsoft.ContainerService" --name "NodePublicIPTagsPreview"
-```
-
-When the status reflects *Registered*, refresh the registration of the *Microsoft.ContainerService* resource provider by using the [`az provider register`][az-provider-register] command:
-
-```azurecli-interactive
-az provider register --namespace Microsoft.ContainerService
-```
 
 ### Create a new cluster using routing preference internet
 
@@ -152,7 +115,6 @@ Examples:
 ### Requirements
 
 * AKS version 1.24 or greater is required.
-* Version 0.5.110 of the aks-preview extension is required.
 
 ### Create a new cluster with allowed ports and application security groups
 

articles/aks/use-node-public-ips.md

@@ -121,7 +121,7 @@ The most recent version of the Flux v2 extension and the two previous versions (
 > [!NOTE]
 > When a new version of the `microsoft.flux` extension is released, it may take several days for the new version to become available in all regions.
 
-### 1.8.4 (March 2024)
+### 1.8.4 (April 2024)
 
 Flux version: [Release v2.1.2](https://github.com/fluxcd/flux2/releases/tag/v2.1.2)
 

articles/azure-arc/kubernetes/extensions-release.md

@@ -173,22 +173,15 @@ To create the HTML:
     <script src="https://atlas.microsoft.com/sdk/javascript/mapcontrol/3/atlas.min.js"></script>
     ```
 
-3. Next, add a reference to the Azure Maps Services module. This module is a JavaScript library that wraps the Azure Maps REST services, making them easy to use in JavaScript. The Services module is useful for powering search functionality.
-
-    ```HTML
-    <!-- Add a reference to the Azure Maps Services Module JavaScript file. -->
-    <script src="https://atlas.microsoft.com/sdk/javascript/service/2/atlas-service.min.js"></script>
-    ```
-
-4. Add references to *index.js* and *index.css*.
+3. Add references to *index.js* and *index.css*.
 
     ```HTML
     <!-- Add references to the store locator JavaScript and CSS files. -->
     <link rel="stylesheet" href="index.css" type="text/css">
     <script src="index.js"></script>
     ```
 
-5. In the body of the document, add a `header` tag. Inside the `header` tag, add the logo and company name.
+4. In the body of the document, add a `header` tag. Inside the `header` tag, add the logo and company name.
 
     ```HTML
     <header>
@@ -197,7 +190,7 @@ To create the HTML:
     </header>
     ```
 
-6. Add a `main` tag and create a search panel that has a text box and search button. Also, add `div` references for the map, the list panel, and the My Location GPS button.
+5. Add a `main` tag and create a search panel that has a text box and search button. Also, add `div` references for the map, the list panel, and the My Location GPS button.
 
     ```HTML
     <main>
@@ -461,7 +454,7 @@ To add the JavaScript:
     var countrySet = ['US', 'CA', 'GB', 'FR','DE','IT','ES','NL','DK'];      
 
     //
-    var map, popup, datasource, iconLayer, centerMarker, searchURL;
+    var map, popup, datasource, iconLayer, centerMarker;
 
     // Used in function updateListItems
     var listItemTemplate = '<div class="listItem" onclick="itemSelected(\'{id}\')"><div class="listItem-title">{title}</div>{city}<br />Open until {closes}<br />{distance} miles away</div>';
@@ -491,12 +484,6 @@ To add the JavaScript:
         //Create a pop-up window, but leave it closed so we can update it and display it later.
         popup = new atlas.Popup();
 
-        //Use MapControlCredential to share authentication between a map control and the service module.
-        var pipeline = atlas.service.MapsURL.newPipeline(new atlas.service.MapControlCredential(map));
-
-        //Create an instance of the SearchURL client.
-        searchURL = new atlas.service.SearchURL(pipeline);
-
         //If the user selects the search button, geocode the value the user passed in.
         document.getElementById('searchBtn').onclick = performSearch;
 
@@ -520,20 +507,28 @@ To add the JavaScript:
 
     function performSearch() {
         var query = document.getElementById('searchTbx').value;
+        //Pass in the array of country/region ISO2 for which we want to limit the search to.
+        var url = `https://atlas.microsoft.com/search/fuzzy/json?api-version=1.0&countrySet=${countrySet}&query=${query}&view=Auto`;
 
         //Perform a fuzzy search on the users query.
-        searchURL.searchFuzzy(atlas.service.Aborter.timeout(3000), query, {
-            //Pass in the array of country/region ISO2 for which we want to limit the search to.
-            countrySet: countrySet,
-            view: 'Auto'
-        }).then(results => {
-            //Parse the response into GeoJSON so that the map can understand.
-            var data = results.geojson.getFeatures();
-
-            if (data.features.length > 0) {
-                //Set the camera to the bounds of the results.
+        fetch(url, {
+            headers: {
+                "Subscription-Key": map.authentication.getToken()
+            }
+        })
+        .then((response) => response.json())
+        .then((response) => {
+            if (Array.isArray(response.results) && response.results.length > 0) {
+                var result = response.results[0];
+                var bbox = [
+                    result.viewport.topLeftPoint.lon,
+                    result.viewport.btmRightPoint.lat,
+                    result.viewport.btmRightPoint.lon,
+                    result.viewport.topLeftPoint.lat
+                ];
+                //Set the camera to the bounds of the first result.
                 map.setCamera({
-                    bounds: data.features[0].bbox,
+                    bounds: bbox,
                     padding: 40
                 });
             } else {

articles/azure-maps/tutorial-create-store-locator.md

@@ -50,9 +50,6 @@ The following steps show you how to create and display the Map control in a web
         <link rel="stylesheet" href="https://atlas.microsoft.com/sdk/javascript/mapcontrol/3/atlas.min.css" type="text/css">
         <script src="https://atlas.microsoft.com/sdk/javascript/mapcontrol/3/atlas.min.js"></script>
 
-        <!-- Add a reference to the Azure Maps Services Module JavaScript file. -->
-        <script src="https://atlas.microsoft.com/sdk/javascript/service/2/atlas-service.min.js"></script>
-
         <script>
             var map, datasource, client;
 
@@ -225,80 +222,92 @@ This section shows you how to use the Azure Maps Route service to get directions
 >[!TIP]
 >The Route service provides APIs to plan *fastest*, *shortest*, *eco*, or *thrilling* routes based on distance, traffic conditions, and mode of transport used. The service also lets users plan future routes based on historical traffic conditions. Users can see the prediction of route durations for any given time. For more information, see [Get Route directions API].
 
-1. In the `GetMap` function, inside the control's `ready` event handler, add the following to the JavaScript code.
-
-    ```JavaScript
-   //Use MapControlCredential to share authentication between a map control and the service module.
-    var pipeline = atlas.service.MapsURL.newPipeline(new atlas.service.MapControlCredential(map));
-    
-    //Construct the RouteURL object
-    var routeURL = new atlas.service.RouteURL(pipeline);
-    ```
-
-    * Use [MapControlCredential] to share authentication between a map control and the service module when creating a new [pipeline] object.
-
-    * The [routeURL] represents a URL to Azure Maps [Route service].
-
-2. After setting up credentials and the URL, add the following JavaScript code to construct a truck route from the start to end points. This route is created and displayed for a truck carrying `USHazmatClass2` classed cargo.
+1. In the `GetMap` function, inside the control's `ready` event handler, add the following JavaScript code to construct a truck route from the start to end points. This route is created and displayed for a truck carrying `USHazmatClass2` classed cargo.
 
     ```JavaScript
-    //Start and end point input to the routeURL
-    var coordinates= [[startPoint.geometry.coordinates[0], startPoint.geometry.coordinates[1]], [endPoint.geometry.coordinates[0], endPoint.geometry.coordinates[1]]];
-
+    //Start and end point input to the search route request
+    var query = startPoint.geometry.coordinates[1] + "," +
+                startPoint.geometry.coordinates[0] + ":" +
+                endPoint.geometry.coordinates[1] + "," +
+                endPoint.geometry.coordinates[0];
     //Make a search route request for a truck vehicle type
-    routeURL.calculateRouteDirections(atlas.service.Aborter.timeout(10000), coordinates,{
-        travelMode: 'truck',
-        vehicleWidth: 2,
-        vehicleHeight: 2,
-        vehicleLength: 5,
-        vehicleLoadType: 'USHazmatClass2'
-    }).then((directions) => {
-        //Get data features from response
-        var data = directions.geojson.getFeatures();
-
-        //Get the route line and add some style properties to it.  
-        var routeLine = data.features[0];
-        routeLine.properties.strokeColor = '#2272B9';
-        routeLine.properties.strokeWidth = 9;
-
-        //Add the route line to the data source. This should render below the car route which will likely be added to the data source faster, so insert it at index 0.
-        datasource.add(routeLine, 0);
+    var truckRouteUrl = `https://atlas.microsoft.com/route/directions/json?api-version=1.0&travelMode=truck&vehicleWidth=2&vehicleHeight=2&vehicleLength=5&vehicleLoadType=USHazmatClass2&query=${query}`;
+    fetch(truckRouteUrl, {
+        headers: {
+            "Subscription-Key": map.authentication.getToken()
+        }
+    })
+    .then((response) => response.json())
+    .then((response) => {
+        var route = response.routes[0];
+        //Create an array to store the coordinates of each turn
+        var routeCoordinates = [];
+        route.legs.forEach((leg) => {
+            var legCoordinates = leg.points.map((point) => {
+                return [point.longitude, point.latitude];
+            });
+            //Add each turn to the array
+            routeCoordinates = routeCoordinates.concat(legCoordinates);
+        });
+
+        //Add the route line to the data source. We want this to render below the car route which will likely be added to the data source faster, so insert it at index 0.
+        datasource.add(
+            new atlas.data.Feature(new atlas.data.LineString(routeCoordinates), {
+                strokeColor: "#2272B9",
+                strokeWidth: 9
+            }),
+            0
+        );
     });
     ```
 
    About the above JavaScript:
 
    * This code queries the Azure Maps Route service through the [Azure Maps Route Directions API].
-   * The route line is then extracted from the GeoJSON feature collection from the response that is extracted using the `geojson.getFeatures()` method.
+   * The route line is then created from the coordinates of each turn from the response.
    * The route line is then added to the data source.
    * Two properties are added to the truck route line: a blue stroke color `#2272B9`, and a stroke width of nine pixels.
    * The route line is given an index of 0 to ensure that the truck route is rendered before any other lines in the data source. The reason is the truck route calculation are often slower than a car route calculation. If the truck route line is added to the data source after the car route, it will render above it.
 
     >[!TIP]
     > To see all possible options and values for the Azure Maps Route Directions API, see [URI Parameters for Post Route Directions].
 
-3. Next, append the following JavaScript code to create a route for a car.
+2. Next, append the following JavaScript code to create a route for a car.
 
     ```JavaScript
-    routeURL.calculateRouteDirections(atlas.service.Aborter.timeout(10000), coordinates).then((directions) => {
-
-        //Get data features from response
-        var data = directions.geojson.getFeatures();
-
-        //Get the route line and add some style properties to it.  
-        var routeLine = data.features[0];
-        routeLine.properties.strokeColor = '#B76DAB';
-        routeLine.properties.strokeWidth = 5;
+    var carRouteUrl = `https://atlas.microsoft.com/route/directions/json?api-version=1.0&query=${query}`;
+    fetch(carRouteUrl, {
+        headers: {
+            "Subscription-Key": map.authentication.getToken()
+        }
+    })
+    .then((response) => response.json())
+    .then((response) => {
+        var route = response.routes[0];
+        //Create an array to store the coordinates of each turn
+        var routeCoordinates = [];
+        route.legs.forEach((leg) => {
+            var legCoordinates = leg.points.map((point) => {
+                return [point.longitude, point.latitude];
+            });
+            //Add each turn to the array
+            routeCoordinates = routeCoordinates.concat(legCoordinates);
+        });
 
-        //Add the route line to the data source. This will add the car route after the truck route.  
-        datasource.add(routeLine);
+        //Add the route line to the data source. This will add the car route after the truck route.
+        datasource.add(
+            new atlas.data.Feature(new atlas.data.LineString(routeCoordinates), {
+                strokeColor: "#B76DAB",
+                strokeWidth: 5
+            })
+        );
     });
     ```
 
    About the above JavaScript:
 
    * This code queries the Azure Maps routing service through the [Azure Maps Route Directions API] method.
-   * The route line is then extracted from the GeoJSON feature collection from the response that is extracted using the `geojson.getFeatures()` method then is added to the data source.
+   * The route line is then created from the coordinates of each turn and added to the data source.
    * Two properties are added to the truck route line: a purple stroke color `#B76DAB`, and a stroke width of five pixels.
 
 4. Save the **TruckRoute.html** file and refresh your web browser. The map should now display both the truck and car routes.
@@ -325,8 +334,6 @@ The next tutorial demonstrates the process of creating a simple store locator us
 [Route service]: /rest/api/maps/route
 [Map control]: how-to-use-map-control.md
 [Get Route directions API]: /rest/api/maps/route/getroutedirections
-[routeURL]: /javascript/api/azure-maps-rest/atlas.service.routeurl
-[pipeline]: /javascript/api/azure-maps-rest/atlas.service.pipeline
 [TrafficOptions interface]: /javascript/api/azure-maps-control/atlas.trafficoptions
 [atlas]: /javascript/api/azure-maps-control/atlas
 [atlas.Map]: /javascript/api/azure-maps-control/atlas.map
@@ -336,8 +343,7 @@ The next tutorial demonstrates the process of creating a simple store locator us
 [Data-driven style expressions]: data-driven-style-expressions-web-sdk.md
 [GeoJSON Point objects]: https://en.wikipedia.org/wiki/GeoJSON
 [setCamera]: /javascript/api/azure-maps-control/atlas.map#setCamera_CameraOptions___CameraBoundsOptions___AnimationOptions_
-[MapControlCredential]: /javascript/api/azure-maps-rest/atlas.service.mapcontrolcredential
-[Azure Maps Route Directions API]: /javascript/api/azure-maps-rest/atlas.service.routeurl#calculateroutedirections-aborter--geojson-position----calculateroutedirectionsoptions-
+[Azure Maps Route Directions API]: /rest/api/maps/route/getroutedirections
 [Truck Route]: https://github.com/Azure-Samples/AzureMapsCodeSamples/tree/main/Samples/Tutorials/Truck%20Route
 [Multiple routes by mode of travel]: https://samples.azuremaps.com/?sample=multiple-routes-by-mode-of-travel
 [URI Parameters for Post Route Directions]: /rest/api/maps/route/postroutedirections#uri-parameters