-kubectl delete --namespace <name of namespace>

-kubectl delete --namespace arc

-ChallengeTokenPath=$(curl -s -D - -H Metadata:true "http://127.0.0.1:40342/metadata/identity/oauth2/token?api-version=2019-11-01&resource=https%3A%2F%2Fmanagement.azure.com" | grep Www-Authenticate | cut -d "=" -f 2 | tr -d "[:cntrl:]")

-ChallengeToken=$(cat $ChallengeTokenPath)

- curl -s -H Metadata:true -H "Authorization: Basic $ChallengeToken" "http://127.0.0.1:40342/metadata/identity/oauth2/token?api-version=2019-11-01&resource=https%3A%2F%2Fmanagement.azure.com"

- current_hostname=$(hostname)

- sudo hostnamectl set-hostname $current_hostname

-description: Learn how Azure Maps extends the GeoJSON spec to include additional geometric shapes. View examples that set up circles and rectangles for use in maps.

-Azure Maps provides a list of powerful APIs to search inside and along geographical features. These APIs adhere to the standard [GeoJSON spec][1] of representing geographical features.

-The [GeoJSON spec][1] supports only the following geometries:

-Some Azure Maps APIs accept geometries that aren't part of the [GeoJSON spec][1]. For instance, the [Search Inside Geometry](/rest/api/maps/search/postsearchinsidegeometry) API accepts Circle and Polygons.

-This article provides a detailed explanation on how Azure Maps extends the [GeoJSON spec][1] to represent certain geometries.

-The `Circle` geometry is not supported by the [GeoJSON spec][1]. We use a `GeoJSON Point Feature` object to represent a circle.

- The circle's center is represented using a `GeoJSON Point` object.

- The circle's `radius` is represented using `GeoJSON Feature`'s properties. The radius value is in _meters_ and must be of the type `double`.

- The circle geometry must also contain the `subType` property. This property must be a part of the `GeoJSON Feature`'s properties and its value should be _Circle_

-#### Example

-Here's how you'll represent a circle using a `GeoJSON Feature` object. Let's center the circle at latitude: 47.639754 and longitude: -122.126986, and assign it a radius equal to 100 meters:

-```json

-The `Rectangle` geometry is not supported by the [GeoJSON spec][1]. We use a `GeoJSON Polygon Feature` object to represent a rectangle. The rectangle extension is primarily used by the Web SDK's drawing tools module.

- The rectangle's corners are represented using the coordinates of a `GeoJSON Polygon` object. There should be five coordinates, one for each corner. And, a fifth coordinate that is the same as the first coordinate, to close the polygon ring. It will be assumed that these coordinates align, and that the developer may rotate them as wanted.

- The rectangle geometry must also contain the `subType` property. This property must be a part of the `GeoJSON Feature`'s properties, and its value should be _Rectangle_

-### Example

-> [Geofence GeoJSON format](geofence-geojson.md)

-> [Azure Maps glossary](glossary.md)

-[1]: https://tools.ietf.org/html/rfc7946

-Azure Maps is a global service that supports specifying a geographic scope, which allows you to limit data residency to the European (EU) or United States (US) geographic areas (geos). All requests (including input data) are stored exclusively in the specified geographic area. For more information on Azure regions and geographies, see [Azure geographies](https://azure.microsoft.com/global-infrastructure/geographies).

-For disaster recovery and high availability, Microsoft may replicate customer data to other regions within the same geographic area. For example, if you use the Azure Maps Europe API geographic endpoint, your requests (including input data) are kept in an Azure datacenter in Europe. This only impacts where request data is saved, it doesn't limit the locations from which the customers, or their end users, may access customer data via Azure Maps API.

-The table below describes the mapping between geography and supported Azure geographic API endpoint. For example, if you want all Azure Maps Search Address requests to be processed and stored within the European Azure geography, use the `eu.atlas.microsoft.com` endpoint.

-> When using the Azure Government cloud, use the `atlas.azure.us` endpoint. For more information, see [Azure Government cloud support](how-to-use-map-control.md#azure-government-cloud-support).

-The following is the [Search - Get Search Address](/rest/api/maps/search/get-search-address) request:

-<a name="aerial-imagery"></a> **Aerial imagery**: See [Satellite imagery](#satellite-imagery).

-<a name="antimeridian"></a> **Antimeridian**: Also known as the 180^th Meridian. This is the point where -180 degrees and 180 degrees of longitude meet. Which is the opposite of the prime meridian on the globe.

-<a name="extended-postal-code"></a> **Extended postal code**: A postal code that may include additional information. For example, in the USA, zip codes have five digits. But, an extended zip code, known as zip+4, includes four additional digits. These additional digits are used to identify a geographic segment within the five-digit delivery area, such as a city block, a group of apartments, or a post office box. Knowing the geographic segment aids in efficient mail sorting and delivery.

-<a name="feature"></a> **Feature**: An object that combines a geometry with an additional metadata information.

-<a name="fuzzy-search"></a> **Fuzzy search**: A search that takes in a free form string of text that may be an address or point of interest.

-<a name="geocode"></a> **Geocode**: An address or location that has been converted into a coordinate that can be used to display that location on a map.

-<a name="geocoding"></a> **Geocoding**: Also known as forward geocoding, is the process of converting address of location data into coordinates.

-<a name="geojson"></a> **GeoJSON**: Is a common JSON-based file format used for storing geographical vector data such as points, lines, and polygons. **Note**: Azure Maps uses an extended version of GeoJSON as [documented here](extend-geojson.md).

-<a name="gml"></a> **GML**: Also known as Geography Markup Language. An XML file extension for storing spatial data.

-<a name="gps"></a> **GPS**: Also known as Global Positioning System, is a system of satellites used for determining a devices position on the earth. The orbiting satellites transmit signals that allow a GPS receiver anywhere on earth to calculate its own location through trilateration.

-<a name="gpx"></a> **GPX**: Also known as GPS eXchange format, is an XML file format commonly created from GPS devices.

-<a name="guid"></a> **GUID**: A globally unique identifier. A string used to uniquely identify an interface, class, type library, component category, or record.

-<a name="hd-maps"></a> **HD maps**: Also known as High Definition Maps, consists of high fidelity road network information such as lane markings, signage, and direction lights required for autonomous driving.

-<a name="linestring"></a> **LineString**: A geometry used to represent a line. Also known as a polyline.

-<a name="marker"></a> **Marker**: Also known as a pin or pushpin, is an icon that represents a point location on a map.

-<a name="multilinestring"></a> **MultiLineString**: A geometry that represents a collection of LineString objects.

-<a name="municipality"></a> **Municipality**: A city or town.

-<a name="point"></a> **Point**: A geometry that represents a single position on the map.

-<a name="polygon"></a> **Polygon**: A solid geometry that represents an area on a map.

-<a name="polyline"></a> **Polyline**: A geometry used to represent a line. Also known as a LineString.

-<a name="prime-meridian"></a> **Prime meridian**: A line of longitude that represents 0-degrees longitude. Generally, longitude values decrease when traveling in a westerly direction until 180 degrees and increase when traveling in easterly directions to -180-degrees.

-<a name="prj"></a> **PRJ**: A text file which often accompanies a Shapefile file that contains information about the projected coordinate system the data set is in.

-<a name="projection"></a> **Projection**: A projected coordinate system based on a map projection such as transverse Mercator, Albers equal area, and Robinson. These provide the ability to project maps of the earth's spherical surface onto a two-dimensional Cartesian coordinate plane. Projected coordinate systems are sometimes referred to as map projections.

-<a name="quadkey"></a> **Quadkey**: A base-4 address index for a tile within a quadtree tiling system. For more information, see [Zoom levels and tile grid](zoom-levels-and-tile-grid.md) documentation for more information.

-<a name="quadtree"></a> **Quadtree**: A data structure in which each node has exactly four children. The tiling system used in Azure Maps uses a quadtree structure such that as a user zooms in one level, each map tile breaks up into four subtiles. For more information, see [Zoom levels and tile grid](zoom-levels-and-tile-grid.md) documentation for more information.

-<a name="queries-per-second-qps"></a> **Queries Per Second (QPS)**: The number of queries or requests that can be made to a service or platform within one second.

-<a name="radial-search"></a> **Radial search**: A spatial query that searches a fixed straight-line distance (as the crow flies) from a point.

-<a name="reverse-geocode"></a> **Reverse geocode**: The process of taking a coordinate and determining the address in which is represents on a map.

-<a name="requests-per-second-rps"></a> **Requests Per Second (RPS)**: See [Queries Per Second (QPS)](#queries-per-second-qps).

-<a name="satellite-imagery"></a> **Satellite imagery**: Imagery that has been captured by planes and satellites pointing straight down.

-<a name="shapefile-shp"></a> **Shapefile (SHP)**: Also known as an ESRI Shapefile, is a vector data storage format for storing the location, shape, and attributes of geographic features. A shapefile is stored in a set of related files.

-<a name="shared-key-authentication"></a> **Shared key authentication**: Shared Key authentication relies on passing Azure Maps account generated keys with each request to Azure Maps. These keys are often referred to as subscription keys. It is recommended that keys are regularly regenerated for security. Two keys are provided so that you can maintain connections using one key while regenerating the other. When you regenerate your keys, you must update any applications that access this account to use the new keys. To learn more about Azure Maps authentication, see [Azure Maps and Azure AD](azure-maps-authentication.md) and [Manage authentication in Azure Maps](how-to-manage-authentication.md).

-<a name="sql-spatial"></a> **SQL spatial**: Refers to the spatial functionality built into SQL Azure and SQL Server 2008 and above. This spatial functionality is also available as a .NET library that can be used independently of SQL Server. For more information, see the [Spatial Data (SQL Server) documentation](/sql/relational-databases/spatial/spatial-data-sql-server) for more information.

-<a name="synchronous-request"></a> **Synchronous request**: An HTTP request opens a connection and waits for a response. Browsers limit the number of concurrent HTTP requests that can be made from a page. If multiple long running synchronous requests are made at the same time, then this limit can be reached. Requests will be delayed until one of the other requests has completed.

-<a name="telematics"></a> **Telematics**: Sending, receiving, and storing information via telecommunication devices in conjunction with effecting control on remote objects.

-<a name="transformation"></a> **Transformation**: The process of converting data between different geographic coordinate systems. You may, for example, have some data that was captured in the United Kingdom and based on the OSGB 1936 geographic coordinate system. Azure Maps uses the [EPSG:3857](https://epsg.io/3857) coordinate reference system variant of WGS84. As such to display the data correctly, it will need to have its coordinates transformed from one system to another.

-<a name="voronoi-diagram"></a> **Voronoi diagram**: A partition of space into areas, or cells, that surround a set of geometric objects, usually point features. These cells, or polygons, must satisfy the criteria for Delaunay triangles. All locations within an area are closer to the object it surrounds than to any other object in the set. Voronoi diagrams are often used to delineate areas of influence around geographic features.

-<a name="web-map-service-wms"></a> **Web Map Service (WMS)**: WMS is an Open Geographic Consortium (OGC) standard that defines image-based map services. WMS services provide map images for specific areas within a map on demand. Images include pre-rendered symbology and may be rendered in one of several named styles if defined by the service.

-<a name="z-coordinate"></a> **Z-coordinate**: See [Altitude](#altitude).

-<a name="Zoom level"></a> **Zoom level**: Specifies the level of detail and how much of the map is visible. When zoomed all the way to level 0, the full world map will often be visible. But, the map will show limited details such as country/region names, borders, and ocean names. When zoomed in closer to level 17, the map will display an area of a few city blocks with detailed road information. In Azure Maps, the highest zoom level is 22. For more information, see the [Zoom levels and tile grid](zoom-levels-and-tile-grid.md) documentation.

-The new datastore will now appear in the list of datastores.

-Once your managed identities and datastore are created, you can add the managed identities to the datastore and simultaneously assign them the **Contributor** and **Storage Blob Data Reader** roles. While it's possible to add roles to your managed identities directly in your managed identities or storage account, you can easily do this while simultaneously associating them with your Azure Maps datastore directly in the datastore pane.

-There are the AzureBlob properties that you'll pass in the body of the HTTP request, and [The user data ID](#the-user-data-id) passed in the URL.

-The following two sections will provide you with details how to get the values to use for the [msiClientId](#the-msiclientid-property), [blobUrl](#the-bloburl-property) properties.

-When using System-assigned managed identities, you don't need to provide a value for the `msiClientId` property. The data registry service will automatically use the system assigned identity of the Azure Maps account when `msiClientId` is null.

-1. A list of containers will appear. Select the container that contains the file you wish to register.

-Now that you have your storage account with the desired files linked to your Azure Maps account through the datastore and have gathered all required properties, you're ready to use the [data registry] API to register those files. If you have multiple files in your Azure storage account that you want to register, you'll need to run the register request for each file (`udid`).

-To get a list of all files registered in an Azure Maps account using the [List][list] request:

-The following is a sample response showing three possible statuses, completed, running and failed:

-The contents of the file will appear in the body of the response. For example, a text based GeoJSON file will appear similar to the following example:

-When you register a file in Azure Maps using the data registry API, an MD5 hash is created from the contents of the file, encoding it into a 128-bit fingerprint and saving it in the `AzureBlob` as the `contentMD5` property. The MD5 hash stored in the `contentMD5` property is used to ensure the data integrity of the file. Since the MD5 hash algorithm always produces the same output given the same input, the data validation process can compare the `contentMD5` property of the file when it was registered against a hash of the file in the Azure storage account to check that it's intact and unmodified. If the hash isn't the same, the validation fails. If the file in the underlying storage account changes, the validation will fail. If you need to modify the contents of a file that has been registered in Azure Maps, you'll need to register it again.

-[data registry]: /rest/api/maps/data-registry

-[list]: /rest/api/maps/data-registry/list

-[Register]: /rest/api/maps/data-registry/register-or-replace

-[Get operation]: /rest/api/maps/data-registry/get-operation

-[storage account overview]: /azure/storage/common/storage-account-overview

-[Azure portal]: https://portal.azure.com/

-[geographic scope]: geographic-scope.md

-The [Logs Ingestion API](logs-ingestion-api-overview.md) in Azure Monitor allows you to send external data to a Log Analytics workspace with a REST API. This tutorial uses the Azure portal to walk through configuration of a new table and a sample application to send log data to Azure Monitor. The sample application collects entries from a text file and

-Instead of directly configuring the schema of the table, you can upload a file with a sample JSON array of data through the portal, and Azure Monitor will set the schema automatically. The sample JSON file must contain one or more log records structured as an array, in the same way they data is sent in the body of an HTTP request of the logs ingestion API call.

- " " Resource:string

- " " *

- " " *

- | parse kind = regex RawData with *

- ':"'

- " - -" * '"'

- RequestType:string

- ' '

- Resource:string

- " " *

- " " *

- New-Item -Path $Output -ItemType "file" -Value ($payload | ConvertTo-Json) -Force

-For more information about Azure Backup for SQL Server VMs (public preview), see [Azure Backup for SQL VMs](/azure/azure-sql/virtual-machines/windows/backup-restore#azbackup).

-`access_token`.

-response=$(curl http://localhost:50342/oauth2/token --data "resource=https://management.azure.com/" -H Metadata:true -s)

-access_token=$(echo $response | python -c 'import sys, json; print (json.load(sys.stdin)["access_token"])')

-echo The access token is $access_token

-curl https://management.azure.com/subscriptions/{subscriptionId}/providers/Microsoft.Compute/virtualMachines?api-version=2021-07-01 -H "Authorization: Bearer $access_token" -H "x-ms-version: 2019-02-02"

- token=$(az account get-access-token --resource "https://management.azure.com/" | jq -r ".accessToken")

- curl -X DELETE https://management.azure.com/providers/Microsoft.Portal/usersettings/cloudconsole?api-version=2017-12-01-preview -H Authorization:"Bearer $token"

- <audio src="string"/></audio>

-spID=$(az identity show \

-resourceID=$(az identity show \

- --object-id $spID \

- --assign-identity $resourceID \

-token=$(curl 'http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https%3A%2F%2Fvault.azure.net' -H Metadata:true | jq -r '.access_token')

-curl https://mykeyvault.vault.azure.net/secrets/SampleSecret/?api-version=2016-10-01 -H "Authorization: Bearer $token"

-rgID=$(az group show --name myResourceGroup --query id --output tsv)

- --assign-identity --scope $rgID \

-spID=$(az container show \

- --object-id $spID \

-userID=$(az identity show --resource-group myResourceGroup --name myACRId --query id --output tsv)

-spID=$(az identity show --resource-group myResourceGroup --name myACRId --query principalId --output tsv)

-echo $userID

-echo $spID

-az role assignment create --assignee $spID --scope <registry-id> --role acrpull

-az container create --name my-containergroup --resource-group myResourceGroup --image <loginServer>/hello-world:v1 --acr-identity $userID --assign-identity $userID --ports 80 --dns-name-label <dns-label>

-az container create --name my-containergroup --resource-group myResourceGroup --image <loginServer>/hello-world:v1 --acr-identity $userID --assign-identity $userID --vnet "/subscriptions/$SUBSCRIPTION_ID/resourceGroups/"/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/resourceGroups/myVNetResourceGroup/providers/ --subnet mySubnetName

-> - When to use Tables instead of Files or Folders.

-> - How to install the MLTable SDK.

-> - How to define a data loading blueprint using an `MLTable` file.

-> - Examples that show use of Tables in Azure ML.

-> - How to use Tables during interactive development (for example, in a notebook).

-The examples relevant to Azure Machine Learning Tables can be found in the following folder of the clone repo:

-1. **An `MLTable` file.** A YAML-based file that defines the data loading *blueprint*. In the MLTable file, you can specify:

-> Azure ML *doesn't* require use of Azure ML Tables (`mltable`) for your tabular data. You can use Azure ML File (`uri_file`) and Folder (`uri_folder`) types, and your own parsing logic loads the data into a Pandas or Spark data frame.

-> If you have a simple CSV file or Parquet folder, it's **easier** to use Azure ML Files/Folders instead of than Tables.

-MLTable can construct a table that contains the storage paths of these images and their folder names (labels), which can be used to stream the images. The following code shows how to create the MLTable:

-The following code shows how to open the storage location in the Pandas data frame, and plot the images in a grid:

-You have your MLTable file currently saved on disk, which makes it hard to share with Team members. When you create a data asset in Azure Machine Learning, your MLTable is uploaded to cloud storage and "bookmarked", which allows your Team members to access the MLTable using a friendly name. Also, the data asset is versioned.

-Now that you have your MLTable stored in the cloud, you and Team members can access it with a friendly name in an interactive session (for example, a notebook):

-## Known issues

-| tierToArchive | Supported for `blockBlob` | Supported | Supported |

-resourceGroupName="<resource-group>"

-storageAccountName="<storage-account>"

-replaceSmbMultichannel="\"smbMultichannelEnabled\": null"

-defaultSmbMultichannelEnabled="\"smbMultichannelEnabled\": false"

-query="{"

-query="${query}smbMultichannelEnabled: protocolSettings.smb.multichannel.enabled"

-query="${query}}"

- --resource-group $resourceGroupName \

- --account-name $storageAccountName \

- --query "${query}")

-protocolSettings="${protocolSettings/$replaceSmbMultichannel/$defaultSmbMultichannelEnabled}"

-echo $protocolSettings

- --resource-group $resourceGroupName \

- --account-name $storageAccountName \

-resourceGroupName="<resource-group>"

-storageAccountName="<storage-account>"

-replaceSmbProtocolVersion="\"smbProtocolVersions\": null"

-replaceSmbChannelEncryption="\"smbChannelEncryption\": null"

-replaceSmbAuthenticationMethods="\"smbAuthenticationMethods\": null"

-replaceSmbKerberosTicketEncryption="\"smbKerberosTicketEncryption\": null"

-defaultSmbProtocolVersions="\"smbProtocolVersions\": \"SMB2.1;SMB3.0;SMB3.1.1\""

-defaultSmbChannelEncryption="\"smbChannelEncryption\": \"AES-128-CCM;AES-128-GCM;AES-256-GCM\""

-defaultSmbAuthenticationMethods="\"smbAuthenticationMethods\": \"NTLMv2;Kerberos\""

-defaultSmbKerberosTicketEncryption="\"smbKerberosTicketEncryption\": \"RC4-HMAC;AES-256\""

-query="{"

-query="${query}smbProtocolVersions: protocolSettings.smb.versions,"

-query="${query}smbChannelEncryption: protocolSettings.smb.channelEncryption,"

-query="${query}smbAuthenticationMethods: protocolSettings.smb.authenticationMethods,"

-query="${query}smbKerberosTicketEncryption: protocolSettings.smb.kerberosTicketEncryption"

-query="${query}}"

-protocolSettings=$(az storage account file-service-properties show \

- --resource-group $resourceGroupName \

- --account-name $storageAccountName \

- --query "${query}")

-protocolSettings="${protocolSettings/$replaceSmbProtocolVersion/$defaultSmbProtocolVersions}"

-protocolSettings="${protocolSettings/$replaceSmbChannelEncryption/$defaultSmbChannelEncryption}"

-protocolSettings="${protocolSettings/$replaceSmbAuthenticationMethods/$defaultSmbAuthenticationMethods}"

-protocolSettings="${protocolSettings/$replaceSmbKerberosTicketEncryption/$defaultSmbKerberosTicketEncryption}"

-echo $protocolSettings

- --resource-group $resourceGroupName \

- --account-name $storageAccountName \

-resourceGroupName="<resource-group>"

-storageAccountName="<storage-account>"

- --resource-group $resourceGroupName \

- --account-name $storageAccountName \

- --resource-group $resourceGroupName \

- --account-name $storageAccountName \

-hostName="mystorageaccount.file.core.windows.net"

-nslookup $hostName

-hostName="mystorageaccount.file.core.windows.net"

-nc -zvw3 $hostName 445

-installDir="/etc/"

-region="<region>"

-resourceGroupName="<resource-group>"

-virtualNetworkName="<desired-vnet-name>"

-virtualNetwork=$(az network vnet create \

- --resource-group $resourceGroupName \

- --name $virtualNetworkName \

- --location $region \

-serviceEndpointSubnet=$(az network vnet subnet create \

- --resource-group $resourceGroupName \

- --vnet-name $virtualNetworkName \

-privateEndpointSubnet=$(az network vnet subnet create \

- --resource-group $resourceGroupName \

- --vnet-name $virtualNetworkName \

-gatewaySubnet=$(az network vnet subnet create \

- --resource-group $resourceGroupName \

- --vnet-name $virtualNetworkName \

-rootCertName="P2SRootCert"

-username="client"

-password="1234"

-sudo ipsec pki --self --in rootKey.pem --dn "CN=$rootCertName" --ca --outform pem > rootCert.pem

-rootCertificate=$(openssl x509 -in rootCert.pem -outform der | base64 -w0 ; echo)

- --dn "CN=$username" \

- --san $username \

-openssl pkcs12 -in "clientCert.pem" -inkey "clientKey.pem" -certfile rootCert.pem -export -out "client.p12" -password "pass:$password"

-vpnName="<desired-vpn-name-here>"

-publicIpAddressName="$vpnName-PublicIP"

-publicIpAddress=$(az network public-ip create \

- --resource-group $resourceGroupName \

- --name $publicIpAddressName \

- --location $region \

- --resource-group $resourceGroupName \

- --name $vpnName \

- --vnet $virtualNetworkName \

- --public-ip-addresses $publicIpAddress \

- --location $region \

- --resource-group $resourceGroupName \

- --gateway-name $vpnName \

- --name $rootCertName \

- --public-cert-data $rootCertificate \

-vpnClient=$(az network vnet-gateway vpn-client generate \

- --resource-group $resourceGroupName \

- --name $vpnName \

-curl $vpnClient --output vpnClient.zip

-vpnServer=$(xmllint --xpath "string(/VpnProfile/VpnServer)" Generic/VpnSettings.xml)

-vpnType=$(xmllint --xpath "string(/VpnProfile/VpnType)" Generic/VpnSettings.xml | tr '[:upper:]' '[:lower:]')

-routes=$(xmllint --xpath "string(/VpnProfile/Routes)" Generic/VpnSettings.xml)

-sudo cp "${installDir}ipsec.conf" "${installDir}ipsec.conf.backup"

-sudo cp "Generic/VpnServerRoot.cer_0" "${installDir}ipsec.d/cacerts"

-sudo cp "${username}.p12" "${installDir}ipsec.d/private"

-conn $virtualNetworkName

- keyexchange=$vpnType

-echo ": P12 client.p12 '$password'" | sudo tee -a "${installDir}ipsec.secrets" >

-sudo ipsec up $virtualNetworkName

- resourceGroupName="<your-resource-group>"

- storageAccountName="<your-storage-account>"

- httpEndpoint=$(az storage account show \

- --resource-group $resourceGroupName \

- --name $storageAccountName \

- smbPath=$(echo $httpEndpoint | cut -c7-${#httpEndpoint})

- fileHost=$(echo $smbPath | tr -d "/")

- nc -zvw3 $fileHost 445

-When you mount a file share on a Linux OS, your remote file share is represented as a folder in your local file system. You can mount file shares to anywhere on your system. The following example mounts under the `/mount` path. You can change this to your preferred path you want by modifying the `$mntRoot` variable.

-resourceGroupName="<resource-group-name>"

-storageAccountName="<storage-account-name>"

-fileShareName="<file-share-name>"

-mntRoot="/mount"

-mntPath="$mntRoot/$storageAccountName/$fileShareName"

-sudo mkdir -p $mntPath

-Next, mount the file share using the `mount` command. In the following example, the `$smbPath` command is populated using the fully qualified domain name for the storage account's file endpoint and `$storageAccountKey` is populated with the storage account key.

-httpEndpoint=$(az storage account show \

- --resource-group $resourceGroupName \

- --name $storageAccountName \

-smbPath=$(echo $httpEndpoint | cut -c7-${#httpEndpoint})$fileShareName

-storageAccountKey=$(az storage account keys list \

- --resource-group $resourceGroupName \

- --account-name $storageAccountName \

-sudo mount -t cifs $smbPath $mntPath -o username=$storageAccountName,password=$storageAccountKey,serverino,nosharesock,actimeo=30,mfsymlinks

-httpEndpoint=$(az storage account show \

- --resource-group $resourceGroupName \

- --name $storageAccountName \

-smbPath=$(echo $httpEndpoint | cut -c7-${#httpEndpoint})$fileShareName

-storageAccountKey=$(az storage account keys list \

- --resource-group $resourceGroupName \

- --account-name $storageAccountName \

-sudo mount -t cifs $smbPath $mntPath -o vers=3.0,username=$storageAccountName,password=$storageAccountKey,serverino,nosharesock,actimeo=30,mfsymlinks

-httpEndpoint=$(az storage account show \

- --resource-group $resourceGroupName \

- --name $storageAccountName \

-smbPath=$(echo $httpEndpoint | cut -c7-${#httpEndpoint})$fileShareName

-storageAccountKey=$(az storage account keys list \

- --resource-group $resourceGroupName \

- --account-name $storageAccountName \

-sudo mount -t cifs $smbPath $mntPath -o vers=2.1,username=$storageAccountName,password=$storageAccountKey,serverino,nosharesock,actimeo=30,mfsymlinks

-When you mount a file share on a Linux OS, your remote file share is represented as a folder in your local file system. You can mount file shares to anywhere on your system. The following example mounts under the `/mount` path. You can change this to your preferred path you want by modifying the `$mntRoot` variable.

-mntRoot="/mount"

-sudo mkdir -p $mntRoot

-resourceGroupName="<resource-group-name>"

-storageAccountName="<storage-account-name>"

-credentialRoot="/etc/smbcredentials"

-storageAccountKey=$(az storage account keys list \

- --resource-group $resourceGroupName \

- --account-name $storageAccountName \

-smbCredentialFile="$credentialRoot/$storageAccountName.cred"

-if [ ! -f $smbCredentialFile ]; then

- echo "username=$storageAccountName" | sudo tee $smbCredentialFile >

- echo "password=$storageAccountKey" | sudo tee -a $smbCredentialFile >

- echo "The credential file $smbCredentialFile already exists, and was not modified."

-sudo chmod 600 $smbCredentialFile

-fileShareName="<file-share-name>"

-mntPath="$mntRoot/$storageAccountName/$fileShareName"

-sudo mkdir -p $mntPath

-httpEndpoint=$(az storage account show \

- --resource-group $resourceGroupName \

- --name $storageAccountName \

-smbPath=$(echo $httpEndpoint | cut -c7-${#httpEndpoint})$fileShareName

-if [ -z "$(grep $smbPath\ $mntPath /etc/fstab)" ]; then

- echo "$smbPath $mntPath cifs nofail,credentials=$smbCredentialFile,serverino,nosharesock,actimeo=30" | sudo tee -a /etc/fstab >

-fileShareName="<file-share-name>"

-httpEndpoint=$(az storage account show \

- --resource-group $resourceGroupName \

- --name $storageAccountName \

-smbPath=$(echo $httpEndpoint | cut -c7-$(expr length $httpEndpoint))$fileShareName

-echo "$fileShareName -fstype=cifs,credentials=$smbCredentialFile :$smbPath" > /etc/auto.fileshares

-# PowerShell & REST APIs for for dedicated SQL pool (formerly SQL DW) in Azure Synapse Analytics

-In this article, you learned how to use autoscale rules to scale horizontally and increase or decrease the *number* of VM instances in your scale set. You can also scale vertically to increase or decrease the VM instance *size*. For more information, see [Vertical autoscale with Virtual Machine Scale Sets](virtual-machine-scale-sets-vertical-scale-reprovision.md).