The azure-native:dbformariadb:Server resource, part of the Pulumi Azure Native provider, provisions Azure Database for MariaDB servers: their compute capacity, storage, security settings, and recovery options. This guide focuses on three capabilities: creating new servers with storage and security, read replication for scaling, and point-in-time and geo-restore for recovery.
MariaDB servers require an Azure resource group and may reference existing servers for replication or restore operations. The examples are intentionally small. Combine them with your own network security, firewall rules, and database schemas.
Create a new server with storage and security settings
Most deployments start by provisioning a server with administrator credentials, compute capacity, and storage configuration.
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const server = new azure_native.dbformariadb.Server("server", {
location: "westus",
properties: {
administratorLogin: "cloudsa",
administratorLoginPassword: "<administratorLoginPassword>",
createMode: "Default",
minimalTlsVersion: azure_native.dbformariadb.MinimalTlsVersionEnum.TLS1_2,
sslEnforcement: azure_native.dbformariadb.SslEnforcementEnum.Enabled,
storageProfile: {
backupRetentionDays: 7,
geoRedundantBackup: azure_native.dbformariadb.GeoRedundantBackup.Enabled,
storageMB: 128000,
},
},
resourceGroupName: "testrg",
serverName: "mariadbtestsvc4",
sku: {
capacity: 2,
family: "Gen5",
name: "GP_Gen5_2",
tier: azure_native.dbformariadb.SkuTier.GeneralPurpose,
},
tags: {
ElasticServer: "1",
},
});
import pulumi
import pulumi_azure_native as azure_native
server = azure_native.dbformariadb.Server("server",
location="westus",
properties={
"administrator_login": "cloudsa",
"administrator_login_password": "<administratorLoginPassword>",
"create_mode": "Default",
"minimal_tls_version": azure_native.dbformariadb.MinimalTlsVersionEnum.TLS1_2,
"ssl_enforcement": azure_native.dbformariadb.SslEnforcementEnum.ENABLED,
"storage_profile": {
"backup_retention_days": 7,
"geo_redundant_backup": azure_native.dbformariadb.GeoRedundantBackup.ENABLED,
"storage_mb": 128000,
},
},
resource_group_name="testrg",
server_name="mariadbtestsvc4",
sku={
"capacity": 2,
"family": "Gen5",
"name": "GP_Gen5_2",
"tier": azure_native.dbformariadb.SkuTier.GENERAL_PURPOSE,
},
tags={
"ElasticServer": "1",
})
package main
import (
dbformariadb "github.com/pulumi/pulumi-azure-native-sdk/dbformariadb/v3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := dbformariadb.NewServer(ctx, "server", &dbformariadb.ServerArgs{
Location: pulumi.String("westus"),
Properties: &dbformariadb.ServerPropertiesForDefaultCreateArgs{
AdministratorLogin: pulumi.String("cloudsa"),
AdministratorLoginPassword: pulumi.String("<administratorLoginPassword>"),
CreateMode: pulumi.String("Default"),
MinimalTlsVersion: pulumi.String(dbformariadb.MinimalTlsVersionEnum_TLS1_2),
SslEnforcement: dbformariadb.SslEnforcementEnumEnabled,
StorageProfile: &dbformariadb.StorageProfileArgs{
BackupRetentionDays: pulumi.Int(7),
GeoRedundantBackup: pulumi.String(dbformariadb.GeoRedundantBackupEnabled),
StorageMB: pulumi.Int(128000),
},
},
ResourceGroupName: pulumi.String("testrg"),
ServerName: pulumi.String("mariadbtestsvc4"),
Sku: &dbformariadb.SkuArgs{
Capacity: pulumi.Int(2),
Family: pulumi.String("Gen5"),
Name: pulumi.String("GP_Gen5_2"),
Tier: pulumi.String(dbformariadb.SkuTierGeneralPurpose),
},
Tags: pulumi.StringMap{
"ElasticServer": pulumi.String("1"),
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var server = new AzureNative.DBforMariaDB.Server("server", new()
{
Location = "westus",
Properties = new AzureNative.DBforMariaDB.Inputs.ServerPropertiesForDefaultCreateArgs
{
AdministratorLogin = "cloudsa",
AdministratorLoginPassword = "<administratorLoginPassword>",
CreateMode = "Default",
MinimalTlsVersion = AzureNative.DBforMariaDB.MinimalTlsVersionEnum.TLS1_2,
SslEnforcement = AzureNative.DBforMariaDB.SslEnforcementEnum.Enabled,
StorageProfile = new AzureNative.DBforMariaDB.Inputs.StorageProfileArgs
{
BackupRetentionDays = 7,
GeoRedundantBackup = AzureNative.DBforMariaDB.GeoRedundantBackup.Enabled,
StorageMB = 128000,
},
},
ResourceGroupName = "testrg",
ServerName = "mariadbtestsvc4",
Sku = new AzureNative.DBforMariaDB.Inputs.SkuArgs
{
Capacity = 2,
Family = "Gen5",
Name = "GP_Gen5_2",
Tier = AzureNative.DBforMariaDB.SkuTier.GeneralPurpose,
},
Tags =
{
{ "ElasticServer", "1" },
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.dbformariadb.Server;
import com.pulumi.azurenative.dbformariadb.ServerArgs;
import com.pulumi.azurenative.dbformariadb.inputs.SkuArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var server = new Server("server", ServerArgs.builder()
.location("westus")
.properties(ServerPropertiesForDefaultCreateArgs.builder()
.administratorLogin("cloudsa")
.administratorLoginPassword("<administratorLoginPassword>")
.createMode("Default")
.minimalTlsVersion("TLS1_2")
.sslEnforcement("Enabled")
.storageProfile(StorageProfileArgs.builder()
.backupRetentionDays(7)
.geoRedundantBackup("Enabled")
.storageMB(128000)
.build())
.build())
.resourceGroupName("testrg")
.serverName("mariadbtestsvc4")
.sku(SkuArgs.builder()
.capacity(2)
.family("Gen5")
.name("GP_Gen5_2")
.tier("GeneralPurpose")
.build())
.tags(Map.of("ElasticServer", "1"))
.build());
}
}
resources:
server:
type: azure-native:dbformariadb:Server
properties:
location: westus
properties:
administratorLogin: cloudsa
administratorLoginPassword: <administratorLoginPassword>
createMode: Default
minimalTlsVersion: TLS1_2
sslEnforcement: Enabled
storageProfile:
backupRetentionDays: 7
geoRedundantBackup: Enabled
storageMB: 128000
resourceGroupName: testrg
serverName: mariadbtestsvc4
sku:
capacity: 2
family: Gen5
name: GP_Gen5_2
tier: GeneralPurpose
tags:
ElasticServer: '1'
The createMode property set to “Default” creates a new server from scratch. The administratorLogin and administratorLoginPassword establish initial access credentials. The sku block defines compute capacity (2 vCores, Gen5 hardware, GeneralPurpose tier), while storageProfile configures storage size (128 GB), backup retention (7 days), and geo-redundant backups. The sslEnforcement and minimalTlsVersion properties enforce encrypted connections with TLS 1.2 or higher.
Create a read replica from an existing server
Applications that need to scale read operations can create replicas that continuously sync from a primary server.
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const server = new azure_native.dbformariadb.Server("server", {
location: "westus",
properties: {
createMode: "Replica",
sourceServerId: "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/MasterResourceGroup/providers/Microsoft.DBforMariaDB/servers/masterserver",
},
resourceGroupName: "TargetResourceGroup",
serverName: "targetserver",
});
import pulumi
import pulumi_azure_native as azure_native
server = azure_native.dbformariadb.Server("server",
location="westus",
properties={
"create_mode": "Replica",
"source_server_id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/MasterResourceGroup/providers/Microsoft.DBforMariaDB/servers/masterserver",
},
resource_group_name="TargetResourceGroup",
server_name="targetserver")
package main
import (
dbformariadb "github.com/pulumi/pulumi-azure-native-sdk/dbformariadb/v3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := dbformariadb.NewServer(ctx, "server", &dbformariadb.ServerArgs{
Location: pulumi.String("westus"),
Properties: &dbformariadb.ServerPropertiesForReplicaArgs{
CreateMode: pulumi.String("Replica"),
SourceServerId: pulumi.String("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/MasterResourceGroup/providers/Microsoft.DBforMariaDB/servers/masterserver"),
},
ResourceGroupName: pulumi.String("TargetResourceGroup"),
ServerName: pulumi.String("targetserver"),
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var server = new AzureNative.DBforMariaDB.Server("server", new()
{
Location = "westus",
Properties = new AzureNative.DBforMariaDB.Inputs.ServerPropertiesForReplicaArgs
{
CreateMode = "Replica",
SourceServerId = "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/MasterResourceGroup/providers/Microsoft.DBforMariaDB/servers/masterserver",
},
ResourceGroupName = "TargetResourceGroup",
ServerName = "targetserver",
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.dbformariadb.Server;
import com.pulumi.azurenative.dbformariadb.ServerArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var server = new Server("server", ServerArgs.builder()
.location("westus")
.properties(ServerPropertiesForReplicaArgs.builder()
.createMode("Replica")
.sourceServerId("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/MasterResourceGroup/providers/Microsoft.DBforMariaDB/servers/masterserver")
.build())
.resourceGroupName("TargetResourceGroup")
.serverName("targetserver")
.build());
}
}
resources:
server:
type: azure-native:dbformariadb:Server
properties:
location: westus
properties:
createMode: Replica
sourceServerId: /subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/MasterResourceGroup/providers/Microsoft.DBforMariaDB/servers/masterserver
resourceGroupName: TargetResourceGroup
serverName: targetserver
The createMode property set to “Replica” creates a read-only copy that replicates data from the sourceServerId. The replica inherits the primary server’s SKU, storage, and security settings automatically. This configuration distributes read workloads across multiple servers without modifying the primary.
Restore a server to a specific point in time
When recovering from data corruption or accidental changes, you can restore servers to a known-good state using Azure’s continuous backup system.
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const server = new azure_native.dbformariadb.Server("server", {
location: "brazilsouth",
properties: {
createMode: "PointInTimeRestore",
restorePointInTime: "2017-12-14T00:00:37.467Z",
sourceServerId: "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver",
},
resourceGroupName: "TargetResourceGroup",
serverName: "targetserver",
sku: {
capacity: 2,
family: "Gen5",
name: "GP_Gen5_2",
tier: azure_native.dbformariadb.SkuTier.GeneralPurpose,
},
tags: {
ElasticServer: "1",
},
});
import pulumi
import pulumi_azure_native as azure_native
server = azure_native.dbformariadb.Server("server",
location="brazilsouth",
properties={
"create_mode": "PointInTimeRestore",
"restore_point_in_time": "2017-12-14T00:00:37.467Z",
"source_server_id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver",
},
resource_group_name="TargetResourceGroup",
server_name="targetserver",
sku={
"capacity": 2,
"family": "Gen5",
"name": "GP_Gen5_2",
"tier": azure_native.dbformariadb.SkuTier.GENERAL_PURPOSE,
},
tags={
"ElasticServer": "1",
})
package main
import (
dbformariadb "github.com/pulumi/pulumi-azure-native-sdk/dbformariadb/v3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := dbformariadb.NewServer(ctx, "server", &dbformariadb.ServerArgs{
Location: pulumi.String("brazilsouth"),
Properties: &dbformariadb.ServerPropertiesForRestoreArgs{
CreateMode: pulumi.String("PointInTimeRestore"),
RestorePointInTime: pulumi.String("2017-12-14T00:00:37.467Z"),
SourceServerId: pulumi.String("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver"),
},
ResourceGroupName: pulumi.String("TargetResourceGroup"),
ServerName: pulumi.String("targetserver"),
Sku: &dbformariadb.SkuArgs{
Capacity: pulumi.Int(2),
Family: pulumi.String("Gen5"),
Name: pulumi.String("GP_Gen5_2"),
Tier: pulumi.String(dbformariadb.SkuTierGeneralPurpose),
},
Tags: pulumi.StringMap{
"ElasticServer": pulumi.String("1"),
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var server = new AzureNative.DBforMariaDB.Server("server", new()
{
Location = "brazilsouth",
Properties = new AzureNative.DBforMariaDB.Inputs.ServerPropertiesForRestoreArgs
{
CreateMode = "PointInTimeRestore",
RestorePointInTime = "2017-12-14T00:00:37.467Z",
SourceServerId = "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver",
},
ResourceGroupName = "TargetResourceGroup",
ServerName = "targetserver",
Sku = new AzureNative.DBforMariaDB.Inputs.SkuArgs
{
Capacity = 2,
Family = "Gen5",
Name = "GP_Gen5_2",
Tier = AzureNative.DBforMariaDB.SkuTier.GeneralPurpose,
},
Tags =
{
{ "ElasticServer", "1" },
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.dbformariadb.Server;
import com.pulumi.azurenative.dbformariadb.ServerArgs;
import com.pulumi.azurenative.dbformariadb.inputs.SkuArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var server = new Server("server", ServerArgs.builder()
.location("brazilsouth")
.properties(ServerPropertiesForRestoreArgs.builder()
.createMode("PointInTimeRestore")
.restorePointInTime("2017-12-14T00:00:37.467Z")
.sourceServerId("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver")
.build())
.resourceGroupName("TargetResourceGroup")
.serverName("targetserver")
.sku(SkuArgs.builder()
.capacity(2)
.family("Gen5")
.name("GP_Gen5_2")
.tier("GeneralPurpose")
.build())
.tags(Map.of("ElasticServer", "1"))
.build());
}
}
resources:
server:
type: azure-native:dbformariadb:Server
properties:
location: brazilsouth
properties:
createMode: PointInTimeRestore
restorePointInTime: 2017-12-14T00:00:37.467Z
sourceServerId: /subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver
resourceGroupName: TargetResourceGroup
serverName: targetserver
sku:
capacity: 2
family: Gen5
name: GP_Gen5_2
tier: GeneralPurpose
tags:
ElasticServer: '1'
The createMode property set to “PointInTimeRestore” creates a new server from the sourceServerId’s backup history. The restorePointInTime specifies the exact timestamp to restore (ISO 8601 format). Azure replays transaction logs to that moment, creating a new server with data as it existed then. The original server remains unchanged.
Restore a server from geo-redundant backup
For disaster recovery across Azure regions, geo-restore creates a new server from geo-redundant backups when the primary region becomes unavailable.
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const server = new azure_native.dbformariadb.Server("server", {
location: "westus",
properties: {
createMode: "GeoRestore",
sourceServerId: "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver",
},
resourceGroupName: "TargetResourceGroup",
serverName: "targetserver",
sku: {
capacity: 2,
family: "Gen5",
name: "GP_Gen5_2",
tier: azure_native.dbformariadb.SkuTier.GeneralPurpose,
},
tags: {
ElasticServer: "1",
},
});
import pulumi
import pulumi_azure_native as azure_native
server = azure_native.dbformariadb.Server("server",
location="westus",
properties={
"create_mode": "GeoRestore",
"source_server_id": "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver",
},
resource_group_name="TargetResourceGroup",
server_name="targetserver",
sku={
"capacity": 2,
"family": "Gen5",
"name": "GP_Gen5_2",
"tier": azure_native.dbformariadb.SkuTier.GENERAL_PURPOSE,
},
tags={
"ElasticServer": "1",
})
package main
import (
dbformariadb "github.com/pulumi/pulumi-azure-native-sdk/dbformariadb/v3"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := dbformariadb.NewServer(ctx, "server", &dbformariadb.ServerArgs{
Location: pulumi.String("westus"),
Properties: &dbformariadb.ServerPropertiesForGeoRestoreArgs{
CreateMode: pulumi.String("GeoRestore"),
SourceServerId: pulumi.String("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver"),
},
ResourceGroupName: pulumi.String("TargetResourceGroup"),
ServerName: pulumi.String("targetserver"),
Sku: &dbformariadb.SkuArgs{
Capacity: pulumi.Int(2),
Family: pulumi.String("Gen5"),
Name: pulumi.String("GP_Gen5_2"),
Tier: pulumi.String(dbformariadb.SkuTierGeneralPurpose),
},
Tags: pulumi.StringMap{
"ElasticServer": pulumi.String("1"),
},
})
if err != nil {
return err
}
return nil
})
}
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var server = new AzureNative.DBforMariaDB.Server("server", new()
{
Location = "westus",
Properties = new AzureNative.DBforMariaDB.Inputs.ServerPropertiesForGeoRestoreArgs
{
CreateMode = "GeoRestore",
SourceServerId = "/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver",
},
ResourceGroupName = "TargetResourceGroup",
ServerName = "targetserver",
Sku = new AzureNative.DBforMariaDB.Inputs.SkuArgs
{
Capacity = 2,
Family = "Gen5",
Name = "GP_Gen5_2",
Tier = AzureNative.DBforMariaDB.SkuTier.GeneralPurpose,
},
Tags =
{
{ "ElasticServer", "1" },
},
});
});
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.dbformariadb.Server;
import com.pulumi.azurenative.dbformariadb.ServerArgs;
import com.pulumi.azurenative.dbformariadb.inputs.SkuArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var server = new Server("server", ServerArgs.builder()
.location("westus")
.properties(ServerPropertiesForGeoRestoreArgs.builder()
.createMode("GeoRestore")
.sourceServerId("/subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver")
.build())
.resourceGroupName("TargetResourceGroup")
.serverName("targetserver")
.sku(SkuArgs.builder()
.capacity(2)
.family("Gen5")
.name("GP_Gen5_2")
.tier("GeneralPurpose")
.build())
.tags(Map.of("ElasticServer", "1"))
.build());
}
}
resources:
server:
type: azure-native:dbformariadb:Server
properties:
location: westus
properties:
createMode: GeoRestore
sourceServerId: /subscriptions/ffffffff-ffff-ffff-ffff-ffffffffffff/resourceGroups/SourceResourceGroup/providers/Microsoft.DBforMariaDB/servers/sourceserver
resourceGroupName: TargetResourceGroup
serverName: targetserver
sku:
capacity: 2
family: Gen5
name: GP_Gen5_2
tier: GeneralPurpose
tags:
ElasticServer: '1'
The createMode property set to “GeoRestore” creates a server in a different region from the sourceServerId’s geo-redundant backup. The location property specifies the target region (here, “westus”). This configuration enables recovery when an entire Azure region experiences an outage, provided geo-redundant backup was enabled on the source server.
Beyond these examples
These snippets focus on specific server-level features: server creation with compute and storage configuration, read replication for scaling, and point-in-time and geo-restore for recovery. They’re intentionally minimal rather than full database deployments.
The examples may reference pre-existing infrastructure such as Azure resource groups and source servers for replication and restore operations. They focus on configuring the server rather than provisioning everything around it.
To keep things focused, common server patterns are omitted, including:
- Network security (publicNetworkAccess, firewall rules, VNet integration)
- High availability configuration
- Monitoring and diagnostic settings
- Database creation and schema management
These omissions are intentional: the goal is to illustrate how each server feature is wired, not provide drop-in database modules. See the Azure Database for MariaDB Server resource reference for all available configuration options.
Let's deploy Azure Database for MariaDB Servers
Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.
Try Pulumi Cloud for FREEFrequently Asked Questions
Server Creation & Restore
What are the different ways to create a MariaDB server?
You can create a server using four createMode values:
- Default - Create a new server with
administratorLoginandadministratorLoginPassword - PointInTimeRestore - Restore from a backup using
sourceServerIdandrestorePointInTime - Replica - Create a read replica using
sourceServerIdof the master server - GeoRestore - Restore from geo-redundant backup using
sourceServerId
How do I restore a server from a specific point in time?
Set
createMode to PointInTimeRestore, provide the sourceServerId of the original server, and specify restorePointInTime with an ISO 8601 timestamp (e.g., “2017-12-14T00:00:37.467Z”).How do I create a read replica of an existing server?
Set
createMode to Replica and provide sourceServerId with the resource ID of the master server. The replica inherits configuration from the master.How do I perform a geo-restore from another region?
Set
createMode to GeoRestore and provide sourceServerId of the server to restore from. Geo-restore requires that geo-redundant backup was enabled on the source server.Security & Access
How do I configure SSL and TLS security for my server?
Set
sslEnforcement to Enabled to require SSL connections, and configure minimalTlsVersion (e.g., TLS1_2) to enforce a minimum TLS version.What does the publicNetworkAccess property control?
The
publicNetworkAccess output property indicates whether public network access is allowed. It can be Enabled or Disabled, but this is an output property set by Azure.Storage & Backup
How do I configure storage and backup retention?
Use the
storageProfile property to set storageMB (storage size), backupRetentionDays (retention period), and geoRedundantBackup (Enabled or Disabled).When is the earliest I can restore my server?
The
earliestRestoreDate output property shows the earliest point-in-time you can restore to, based on your backup retention configuration.SKU & Pricing Tier
How do I specify the server's pricing tier and capacity?
Configure the
sku property with capacity (vCores), family (e.g., Gen5), name (e.g., GP_Gen5_2), and tier (e.g., GeneralPurpose).Immutability & Limitations
What properties can't be changed after server creation?
The
serverName and resourceGroupName are immutable. To change these, you must create a new server.How do I find my server's connection endpoint?
Use the
fullyQualifiedDomainName output property, which provides the complete DNS name for connecting to your server.