Tutorial: Install a LEMP stack on an Azure Linux VM
Applies to: ✔️ Linux VMs
This article walks you through how to deploy an NGINX web server, Azure MySQL Flexible Server, and PHP (the LEMP stack) on an Ubuntu Linux VM in Azure. To see the LEMP server in action, you can optionally install and configure a WordPress site. In this tutorial you learn how to:
- Create an Ubuntu VM
- Open ports 80 and 443 for web traffic
- Install and Secure NGINX, Azure Flexible MySQL Server, and PHP
- Verify installation and configuration
- Install WordPress This setup is for quick tests or proof of concept. For more on the LEMP stack, including recommendations for a production environment, see the Ubuntu documentation.
This tutorial uses the CLI within the Azure Cloud Shell, which is constantly updated to the latest version. To open the Cloud Shell, select Try it from the top of any code block.
If you choose to install and use the CLI locally, this tutorial requires that you're running the Azure CLI version 2.0.30 or later. Find the version by running the az --version command. If you need to install or upgrade, see Install Azure CLI.
Variable declaration
First we need to define a few variables that help with the configuration of the LEMP workload.
export NETWORK_PREFIX="$(($RANDOM % 254 + 1))"
export RANDOM_ID="$(openssl rand -hex 3)"
export MY_RESOURCE_GROUP_NAME="myLEMPResourceGroup$RANDOM_ID"
export REGION="westeurope"
export MY_VM_NAME="myVM$RANDOM_ID"
export MY_VM_USERNAME="azureadmin"
export MY_VM_SIZE='Standard_DS2_v2'
export MY_VM_IMAGE='Canonical:0001-com-ubuntu-minimal-jammy:minimal-22_04-lts-gen2:latest'
export MY_PUBLIC_IP_NAME="myPublicIP$RANDOM_ID"
export MY_DNS_LABEL="mydnslabel$RANDOM_ID"
export MY_NSG_NAME="myNSG$RANDOM_ID"
export MY_NSG_SSH_RULE="Allow-Access$RANDOM_ID"
export MY_VM_NIC_NAME="myVMNic$RANDOM_ID"
export MY_VNET_NAME="myVNet$RANDOM_ID"
export MY_VNET_PREFIX="10.$NETWORK_PREFIX.0.0/22"
export MY_SN_NAME="mySN$RANDOM_ID"
export MY_SN_PREFIX="10.$NETWORK_PREFIX.0.0/24"
export MY_MYSQL_DB_NAME="mydb$RANDOM_ID"
export MY_MYSQL_ADMIN_USERNAME="dbadmin$RANDOM_ID"
export MY_MYSQL_ADMIN_PW="$(openssl rand -base64 32)"
export MY_MYSQL_SN_NAME="myMySQLSN$RANDOM_ID"
export MY_WP_ADMIN_PW="$(openssl rand -base64 32)"
export MY_WP_ADMIN_USER="wpcliadmin"
export MY_AZURE_USER=$(az account show --query user.name --output tsv)
export FQDN="${MY_DNS_LABEL}.${REGION}.cloudapp.azure.com"
Create a resource group
Create a resource group with the az group create command. An Azure resource group is a logical container into which Azure resources are deployed and managed.
The following example creates a resource group named $MY_RESOURCE_GROUP_NAME in the eastus location.
az group create \
--name $MY_RESOURCE_GROUP_NAME \
--location $REGION -o JSON
Results:
{
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx",
"location": "eastus",
"managedBy": null,
"name": "myLEMPResourceGroupxxxxxx",
"properties": {
"provisioningState": "Succeeded"
},
"tags": null,
"type": "Microsoft.Resources/resourceGroups"
}
Setup LEMP networking
Create an Azure Virtual Network
A virtual network is the fundamental building block for private networks in Azure. Azure Virtual Network enables Azure resources like VMs to securely communicate with each other and the internet.
Use az network vnet create to create a virtual network named $MY_VNET_NAME with a subnet named $MY_SN_NAME in the $MY_RESOURCE_GROUP_NAME resource group.
az network vnet create \
--name $MY_VNET_NAME \
--resource-group $MY_RESOURCE_GROUP_NAME \
--location $REGION \
--address-prefix $MY_VNET_PREFIX \
--subnet-name $MY_SN_NAME \
--subnet-prefixes $MY_SN_PREFIX -o JSON
Results:
{
"newVNet": {
"addressSpace": {
"addressPrefixes": [
"10.19.0.0/22"
]
},
"enableDdosProtection": false,
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Network/virtualNetworks/myVNetxxxxxx",
"location": "eastus",
"name": "myVNetxxxxxx",
"provisioningState": "Succeeded",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"subnets": [
{
"addressPrefix": "10.19.0.0/24",
"delegations": [],
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Network/virtualNetworks/myVNetxxxxxx/subnets/mySNxxxxxx",
"name": "mySNxxxxxx",
"privateEndpointNetworkPolicies": "Disabled",
"privateLinkServiceNetworkPolicies": "Enabled",
"provisioningState": "Succeeded",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"type": "Microsoft.Network/virtualNetworks/subnets"
}
],
"type": "Microsoft.Network/virtualNetworks",
"virtualNetworkPeerings": []
}
}
Create an Azure Public IP
Use az network public-ip create to create a standard zone-redundant public IPv4 address named MY_PUBLIC_IP_NAME in $MY_RESOURCE_GROUP_NAME.
Note
The below options for zones are only valid selections in regions with Availability Zones.
az network public-ip create \
--name $MY_PUBLIC_IP_NAME \
--location $REGION \
--resource-group $MY_RESOURCE_GROUP_NAME \
--dns-name $MY_DNS_LABEL \
--sku Standard \
--allocation-method static \
--version IPv4 \
--zone 1 2 3 -o JSON
Results:
{
"publicIp": {
"ddosSettings": {
"protectionMode": "VirtualNetworkInherited"
},
"dnsSettings": {
"domainNameLabel": "mydnslabelxxxxxx",
"fqdn": "mydnslabelxxxxxx.eastus.cloudapp.azure.com"
},
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Network/publicIPAddresses/myPublicIPxxxxxx",
"idleTimeoutInMinutes": 4,
"ipTags": [],
"location": "eastus",
"name": "myPublicIPxxxxxx",
"provisioningState": "Succeeded",
"publicIPAddressVersion": "IPv4",
"publicIPAllocationMethod": "Static",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"sku": {
"name": "Standard",
"tier": "Regional"
},
"type": "Microsoft.Network/publicIPAddresses",
"zones": [
"1",
"2",
"3"
]
}
}
Create an Azure Network Security Group
Security rules in network security groups enable you to filter the type of network traffic that can flow in and out of virtual network subnets and network interfaces. To learn more about network security groups, see Network security group overview.
az network nsg create \
--name $MY_NSG_NAME \
--resource-group $MY_RESOURCE_GROUP_NAME \
--location $REGION -o JSON
Results:
{
"NewNSG": {
"defaultSecurityRules":
{
"access": "Allow",
"description": "Allow inbound traffic from all VMs in VNET",
"destinationAddressPrefix": "VirtualNetwork",
"destinationAddressPrefixes": [],
"destinationPortRange": "*",
"destinationPortRanges": [],
"direction": "Inbound",
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroup104/providers/Microsoft.Network/networkSecurityGroups/protect-vms/defaultSecurityRules/AllowVnetInBound",
"name": "AllowVnetInBound",
"priority": 65000,
"protocol": "*",
"provisioningState": "Succeeded",
"resourceGroup": "myLEMPResourceGroup104",
"sourceAddressPrefix": "VirtualNetwork",
"sourceAddressPrefixes": [],
"sourcePortRange": "*",
"sourcePortRanges": [],
"type": "Microsoft.Network/networkSecurityGroups/defaultSecurityRules"
},
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroup104/providers/Microsoft.Network/networkSecurityGroups/protect-vms",
"location": "eastus",
"name": "protect-vms",
"provisioningState": "Succeeded",
"resourceGroup": "myLEMPResourceGroup104",
"securityRules": [],
"type": "Microsoft.Network/networkSecurityGroups"
}
}
Create Azure Network Security Group rules
Create a rule to allow connections to the virtual machine on port 22 for SSH and ports 80, 443 for HTTP and HTTPS. An extra rule is created to allow all ports for outbound connections. Use az network nsg rule create to create a network security group rule.
az network nsg rule create \
--resource-group $MY_RESOURCE_GROUP_NAME \
--nsg-name $MY_NSG_NAME \
--name $MY_NSG_SSH_RULE \
--access Allow \
--protocol Tcp \
--direction Inbound \
--priority 100 \
--source-address-prefix '*' \
--source-port-range '*' \
--destination-address-prefix '*' \
--destination-port-range 22 80 443 -o JSON
Results:
{
"access": "Allow",
"destinationAddressPrefix": "*",
"destinationAddressPrefixes": [],
"destinationPortRanges": [
"22",
"80",
"443"
],
"direction": "Inbound",
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Network/networkSecurityGroups/myNSGNamexxxxxx/securityRules/Allow-Accessxxxxxx",
"name": "Allow-Accessxxxxxx",
"priority": 100,
"protocol": "Tcp",
"provisioningState": "Succeeded",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"sourceAddressPrefix": "*",
"sourceAddressPrefixes": [],
"sourcePortRange": "*",
"sourcePortRanges": [],
"type": "Microsoft.Network/networkSecurityGroups/securityRules"
}
Create an Azure Network Interface
Use az network nic create to create the network interface for the virtual machine. The public IP addresses and the NSG created previously are associated with the NIC. The network interface is attached to the virtual network you created previously.
az network nic create \
--resource-group $MY_RESOURCE_GROUP_NAME \
--name $MY_VM_NIC_NAME \
--location $REGION \
--ip-forwarding false \
--subnet $MY_SN_NAME \
--vnet-name $MY_VNET_NAME \
--network-security-group $MY_NSG_NAME \
--public-ip-address $MY_PUBLIC_IP_NAME -o JSON
Results:
{
"NewNIC": {
"auxiliaryMode": "None",
"auxiliarySku": "None",
"disableTcpStateTracking": false,
"dnsSettings": {
"appliedDnsServers": [],
"dnsServers": []
},
"enableAcceleratedNetworking": false,
"enableIPForwarding": false,
"hostedWorkloads": [],
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Network/networkInterfaces/myVMNicNamexxxxxx",
"ipConfigurations": [
{
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Network/networkInterfaces/myVMNicNamexxxxxx/ipConfigurations/ipconfig1",
"name": "ipconfig1",
"primary": true,
"privateIPAddress": "10.19.0.4",
"privateIPAddressVersion": "IPv4",
"privateIPAllocationMethod": "Dynamic",
"provisioningState": "Succeeded",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"subnet": {
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Network/virtualNetworks/myVNetxxxxxx/subnets/mySNxxxxxx",
"resourceGroup": "myLEMPResourceGroupxxxxxx"
},
"type": "Microsoft.Network/networkInterfaces/ipConfigurations"
}
],
"location": "eastus",
"name": "myVMNicNamexxxxxx",
"networkSecurityGroup": {
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Network/networkSecurityGroups/myNSGNamexxxxxx",
"resourceGroup": "myLEMPResourceGroupxxxxxx"
},
"nicType": "Standard",
"provisioningState": "Succeeded",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"tapConfigurations": [],
"type": "Microsoft.Network/networkInterfaces",
"vnetEncryptionSupported": false
}
}
Cloud-init overview
Cloud-init is a widely used approach to customize a Linux VM as it boots for the first time. You can use cloud-init to install packages and write files, or to configure users and security. As cloud-init runs during the initial boot process, there are no other steps or required agents to apply to your configuration.
Cloud-init also works across distributions. For example, you don't use apt-get install or yum install to install a package. Instead you can define a list of packages to install. Cloud-init automatically uses the native package management tool for the distro you select.
We're working with our partners to get cloud-init included and working in the images that they provide to Azure. For detailed information cloud-init support for each distribution, see Cloud-init support for VMs in Azure.
Create cloud-init config file
To see cloud-init in action, create a VM that installs a LEMP stack and runs a simple Wordpress app secured with an SSL certificate. The following cloud-init configuration installs the required packages, creates the Wordpress website, then initialize and starts the website.
cat << EOF > cloud-init.txt
#cloud-config
# Install, update, and upgrade packages
package_upgrade: true
package_update: true
package_reboot_if_require: true
# Install packages
packages:
- vim
- certbot
- python3-certbot-nginx
- bash-completion
- nginx
- mysql-client
- php
- php-cli
- php-bcmath
- php-curl
- php-imagick
- php-intl
- php-json
- php-mbstring
- php-mysql
- php-gd
- php-xml
- php-xmlrpc
- php-zip
- php-fpm
write_files:
- owner: www-data:www-data
path: /etc/nginx/sites-available/default.conf
content: |
server {
listen 80 default_server;
listen [::]:80 default_server;
root /var/www/html;
server_name $FQDN;
}
write_files:
- owner: www-data:www-data
path: /etc/nginx/sites-available/$FQDN.conf
content: |
upstream php {
server unix:/run/php/php8.1-fpm.sock;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name $FQDN;
ssl_certificate /etc/letsencrypt/live/$FQDN/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/$FQDN/privkey.pem;
root /var/www/$FQDN;
index index.php;
location / {
try_files \$uri \$uri/ /index.php?\$args;
}
location ~ \.php$ {
include fastcgi_params;
fastcgi_intercept_errors on;
fastcgi_pass php;
fastcgi_param SCRIPT_FILENAME \$document_root\$fastcgi_script_name;
}
location ~* \.(js|css|png|jpg|jpeg|gif|ico)$ {
expires max;
log_not_found off;
}
location = /favicon.ico {
log_not_found off;
access_log off;
}
location = /robots.txt {
allow all;
log_not_found off;
access_log off;
}
}
server {
listen 80;
listen [::]:80;
server_name $FQDN;
return 301 https://$FQDN\$request_uri;
}
runcmd:
- sed -i 's/;cgi.fix_pathinfo.*/cgi.fix_pathinfo = 1/' /etc/php/8.1/fpm/php.ini
- sed -i 's/^max_execution_time \= .*/max_execution_time \= 300/g' /etc/php/8.1/fpm/php.ini
- sed -i 's/^upload_max_filesize \= .*/upload_max_filesize \= 64M/g' /etc/php/8.1/fpm/php.ini
- sed -i 's/^post_max_size \= .*/post_max_size \= 64M/g' /etc/php/8.1/fpm/php.ini
- systemctl restart php8.1-fpm
- systemctl restart nginx
- certbot --nginx certonly --non-interactive --agree-tos -d $FQDN -m dummy@dummy.com --redirect
- ln -s /etc/nginx/sites-available/$FQDN.conf /etc/nginx/sites-enabled/
- rm /etc/nginx/sites-enabled/default
- systemctl restart nginx
- curl --url https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar --output /tmp/wp-cli.phar
- mv /tmp/wp-cli.phar /usr/local/bin/wp
- chmod +x /usr/local/bin/wp
- wp cli update
- mkdir -m 0755 -p /var/www/$FQDN
- chown -R azureadmin:www-data /var/www/$FQDN
- sudo -u azureadmin -i -- wp core download --path=/var/www/$FQDN
- sudo -u azureadmin -i -- wp config create --dbhost=$MY_MYSQL_DB_NAME.mysql.database.azure.com --dbname=wp001 --dbuser=$MY_MYSQL_ADMIN_USERNAME --dbpass="$MY_MYSQL_ADMIN_PW" --path=/var/www/$FQDN
- sudo -u azureadmin -i -- wp core install --url=$FQDN --title="Azure hosted blog" --admin_user=$MY_WP_ADMIN_USER --admin_password="$MY_WP_ADMIN_PW" --admin_email=$MY_AZURE_USER --path=/var/www/$FQDN
- sudo -u azureadmin -i -- wp plugin update --all --path=/var/www/$FQDN
- chmod 600 /var/www/$FQDN/wp-config.php
- mkdir -p -m 0775 /var/www/$FQDN/wp-content/uploads
- chgrp www-data /var/www/$FQDN/wp-content/uploads
EOF
Create an Azure Private DNS Zone for Azure MySQL Flexible Server
Azure Private DNS Zone integration allows you to resolve the private DNS within the current VNET or any in-region peered VNET where the private DNS Zone is linked. Use az network private-dns zone create to create the private DNS zone.
az network private-dns zone create \
--resource-group $MY_RESOURCE_GROUP_NAME \
--name $MY_DNS_LABEL.private.mysql.database.azure.com -o JSON
Results:
{
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Network/privateDnsZones/mydnslabelxxxxxx.private.mysql.database.azure.com",
"location": "global",
"maxNumberOfRecordSets": 25000,
"maxNumberOfVirtualNetworkLinks": 1000,
"maxNumberOfVirtualNetworkLinksWithRegistration": 100,
"name": "mydnslabelxxxxxx.private.mysql.database.azure.com",
"numberOfRecordSets": 1,
"numberOfVirtualNetworkLinks": 0,
"numberOfVirtualNetworkLinksWithRegistration": 0,
"provisioningState": "Succeeded",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"tags": null,
"type": "Microsoft.Network/privateDnsZones"
}
Create an Azure Database for MySQL - Flexible Server
Azure Database for MySQL - Flexible Server is a managed service that you can use to run, manage, and scale highly available MySQL servers in the cloud. Create a flexible server with the az mysql flexible-server create command. A server can contain multiple databases. The following command creates a server using service defaults and variable values from your Azure CLI's local environment:
az mysql flexible-server create \
--admin-password $MY_MYSQL_ADMIN_PW \
--admin-user $MY_MYSQL_ADMIN_USERNAME \
--auto-scale-iops Disabled \
--high-availability Disabled \
--iops 500 \
--location $REGION \
--name $MY_MYSQL_DB_NAME \
--database-name wp001 \
--resource-group $MY_RESOURCE_GROUP_NAME \
--sku-name Standard_B2s \
--storage-auto-grow Disabled \
--storage-size 20 \
--subnet $MY_MYSQL_SN_NAME \
--private-dns-zone $MY_DNS_LABEL.private.mysql.database.azure.com \
--tier Burstable \
--version 8.0.21 \
--vnet $MY_VNET_NAME \
--yes -o JSON
Results:
{
"databaseName": "wp001",
"host": "mydbxxxxxx.mysql.database.azure.com",
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.DBforMySQL/flexibleServers/mydbxxxxxx",
"location": "East US",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"skuname": "Standard_B2s",
"subnetId": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Network/virtualNetworks/myVNetxxxxxx/subnets/myMySQLSNxxxxxx",
"username": "dbadminxxxxxx",
"version": "8.0.21"
}
echo "Your MySQL user $MY_MYSQL_ADMIN_USERNAME password is: $MY_WP_ADMIN_PW"
The server created has the below attributes:
- The server name, admin username, admin password, resource group name, location are already specified in local context environment of the cloud shell. They're created in the same location as your resource group and other Azure components.
- Service defaults for remaining server configurations: compute tier (Burstable), compute size/SKU (Standard_B2s), backup retention period (7 days), and MySQL version (8.0.21)
- The default connectivity method is Private access (VNet Integration) with a linked virtual network and an auto-generated subnet.
Note
The connectivity method cannot be changed after creating the server. For example, if you selected Private access (VNet Integration) during create then you cannot change to Public access (allowed IP addresses) after create. We highly recommend creating a server with Private access to securely access your server using VNet Integration. Learn more about Private access in the concepts article.
If you'd like to change any defaults, refer to the Azure CLI reference documentation for the complete list of configurable CLI parameters.
Check the Azure Database for MySQL - Flexible Server status
It takes a few minutes to create the Azure Database for MySQL - Flexible Server and supporting resources.
runtime="10 minute";
endtime=$(date -ud "$runtime" +%s);
while [[ $(date -u +%s) -le $endtime ]]; do
STATUS=$(az mysql flexible-server show -g $MY_RESOURCE_GROUP_NAME -n $MY_MYSQL_DB_NAME --query state -o tsv);
echo $STATUS;
if [ "$STATUS" == 'Ready' ]; then
break;
else
sleep 10;
fi;
done
Configure server parameters in Azure Database for MySQL - Flexible Server
You can manage Azure Database for MySQL - Flexible Server configuration using server parameters. The server parameters are configured with the default and recommended value when you create the server.
Show server parameter details:
Run the az mysql flexible-server parameter show command to show details about any particular parameter for the server.
Disable Azure Database for MySQL - Flexible Server SSL connection parameter for Wordpress integration
Modify a server parameter value:
You can also modify the value of a certain server parameter, which updates the underlying configuration value for the MySQL server engine. To update the server parameter, use the az mysql flexible-server parameter set command.
az mysql flexible-server parameter set \
-g $MY_RESOURCE_GROUP_NAME \
-s $MY_MYSQL_DB_NAME \
-n require_secure_transport -v "OFF" -o JSON
Results:
{
"allowedValues": "ON,OFF",
"currentValue": "OFF",
"dataType": "Enumeration",
"defaultValue": "ON",
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.DBforMySQL/flexibleServers/mydbxxxxxx/configurations/require_secure_transport",
"isConfigPendingRestart": "False",
"isDynamicConfig": "True",
"isReadOnly": "False",
"name": "require_secure_transport",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"source": "user-override",
"systemData": null,
"type": "Microsoft.DBforMySQL/flexibleServers/configurations",
"value": "OFF"
}
Create an Azure Linux Virtual Machine
The following example creates a VM named $MY_VM_NAME and creates SSH keys if they don't already exist in a default key location. The command also sets $MY_VM_USERNAME as an administrator user name.
To improve the security of Linux virtual machines in Azure, you can integrate with Azure Active Directory authentication. Now you can use Azure AD as a core authentication platform. You can also SSH into the Linux VM by using Azure AD and OpenSSH certificate-based authentication. This functionality allows organizations to manage access to VMs with Azure role-based access control and Conditional Access policies.
Create a VM with the az vm create command.
az vm create \
--name $MY_VM_NAME \
--resource-group $MY_RESOURCE_GROUP_NAME \
--admin-username $MY_VM_USERNAME \
--authentication-type ssh \
--assign-identity \
--image $MY_VM_IMAGE \
--location $REGION \
--nic-delete-option Delete \
--os-disk-caching ReadOnly \
--os-disk-delete-option Delete \
--os-disk-size-gb 30 \
--size $MY_VM_SIZE \
--generate-ssh-keys \
--storage-sku Premium_LRS \
--nics $MY_VM_NIC_NAME \
--custom-data cloud-init.txt -o JSON
Results:
{
"fqdns": "mydnslabelxxxxxx.eastus.cloudapp.azure.com",
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Compute/virtualMachines/myVMNamexxxxxx",
"identity": {
"principalId": "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy",
"tenantId": "zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz",
"type": "SystemAssigned",
"userAssignedIdentities": null
},
"location": "eastus",
"macAddress": "60-45-BD-D8-1D-84",
"powerState": "VM running",
"privateIpAddress": "10.19.0.4",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"zones": ""
}
Check the Azure Linux Virtual Machine status
It takes a few minutes to create the VM and supporting resources. The provisioningState value of Succeeded appears when the extension is successfully installed on the VM. The VM must have a running VM agent to install the extension.
runtime="5 minute";
endtime=$(date -ud "$runtime" +%s);
while [[ $(date -u +%s) -le $endtime ]]; do
STATUS=$(ssh -o StrictHostKeyChecking=no $MY_VM_USERNAME@$FQDN "cloud-init status --wait");
echo $STATUS;
if [[ "$STATUS" == *'status: done'* ]]; then
break;
else
sleep 10;
fi;
done
{
"condition": null,
"conditionVersion": null,
"createdBy": null,
"createdOn": "2023-09-04T09:29:16.895907+00:00",
"delegatedManagedIdentityResourceId": null,
"description": null,
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Authorization/roleAssignments/yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy",
"name": "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy",
"principalId": "zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz",
"principalType": "User",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"roleDefinitionId": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/providers/Microsoft.Authorization/roleDefinitions/zzzzzzzz-zzzz-zzzz-zzzz-zzzzzzzzzzzz",
"scope": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx",
"type": "Microsoft.Authorization/roleAssignments",
"updatedBy": "wwwwwwww-wwww-wwww-wwww-wwwwwwwwwwww",
"updatedOn": "2023-09-04T09:29:17.237445+00:00"
}
Enable Azure AD login for a Linux Virtual Machine in Azure
The following installs the extension to enable Azure AD login for a Linux VM. VM extensions are small applications that provide post-deployment configuration and automation tasks on Azure virtual machines.
az vm extension set \
--publisher Microsoft.Azure.ActiveDirectory \
--name AADSSHLoginForLinux \
--resource-group $MY_RESOURCE_GROUP_NAME \
--vm-name $MY_VM_NAME -o JSON
Results:
{
"autoUpgradeMinorVersion": true,
"enableAutomaticUpgrade": null,
"forceUpdateTag": null,
"id": "/subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/resourceGroups/myLEMPResourceGroupxxxxxx/providers/Microsoft.Compute/virtualMachines/myVMNamexxxxxx/extensions/AADSSHLoginForLinux",
"instanceView": null,
"location": "eastus",
"name": "AADSSHLoginForLinux",
"protectedSettings": null,
"protectedSettingsFromKeyVault": null,
"provisioningState": "Succeeded",
"publisher": "Microsoft.Azure.ActiveDirectory",
"resourceGroup": "myLEMPResourceGroupxxxxxx",
"settings": null,
"suppressFailures": null,
"tags": null,
"type": "Microsoft.Compute/virtualMachines/extensions",
"typeHandlerVersion": "1.0",
"typePropertiesType": "AADSSHLoginForLinux"
}
Check and browse your WordPress website
WordPress is an open source content management system (CMS) used by over 40% of the web to create websites, blogs, and other applications. WordPress can be run on a few different Azure services: AKS, Virtual Machines, and App Service. For a full list of WordPress options on Azure, see WordPress on Azure Marketplace.
This WordPress setup is only for proof of concept. To install the latest WordPress in production with recommended security settings, see the WordPress documentation.
Validate that the application is running by curling the application url:
runtime="5 minute";
endtime=$(date -ud "$runtime" +%s);
while [[ $(date -u +%s) -le $endtime ]]; do
if curl -I -s -f $FQDN > /dev/null ; then
curl -L -s -f $FQDN 2> /dev/null | head -n 9
break
else
sleep 10
fi;
done
Results:
<!DOCTYPE html>
<html lang="en-US">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<meta name='robots' content='max-image-preview:large' />
<title>Azure hosted blog</title>
<link rel="alternate" type="application/rss+xml" title="Azure hosted blog » Feed" href="https://mydnslabelxxxxxx.eastus.cloudapp.azure.com/?feed=rss2" />
<link rel="alternate" type="application/rss+xml" title="Azure hosted blog » Comments Feed" href="https://mydnslabelxxxxxx.eastus.cloudapp.azure.com/?feed=comments-rss2" />
echo "You can now visit your web server at https://$FQDN"
Feedback
Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see: https://aka.ms/ContentUserFeedback.
Submit and view feedback for