Azure Managed Redis

Connect

Start Vera as in Get started, with your license key activated and the emulator started by the Vera launcher (Activate Pro). Then open Bash in a terminal of its own (on macOS, whose terminal starts zsh, type bash first), go to an empty scratch directory and run this; it needs curl and Python 3, and jq. It fetches the emulator's own certificate, so every request checks TLS, and defines data_request and data_arm, which this page's commands use. The bearer token vera-local is a dummy local credential, not your license key.

export VERA_CA_CERT="$PWD/vera-ca.pem"
curl --fail --silent --show-error --noproxy '*' --insecure \
  https://localhost:8543/_vera/ca.pem --output "$VERA_CA_CERT"
curl --fail --silent --show-error --noproxy '*' \
  --cacert "$VERA_CA_CERT" https://localhost:8543/_vera/health; echo

export VERA_CA="$VERA_CA_CERT"
export ARM='https://localhost:8543'
export SUB='00000000-0000-0000-0000-000000000001'
export TENANT='00000000-0000-0000-0000-0000000000a1'
export RG='azdata-rg'
export ROOT="/subscriptions/$SUB/resourceGroups/$RG"
export AUDIT_TMP="$(mktemp -d)"

56 more lines: show the full setup
# Every .localhost host name is connected to loopback, and TLS is verified.
# DATA_RESPONSE is replaced after each call: copy any IDs before the next one.
data_request() {
  local method="$1" url="$2" host status
  shift 2
  case "$url" in
    https://localhost:8543/*|https://*.localhost:8543/*) ;;
    *) printf 'Refusing non-local URL: %s\n' "$url" >&2; return 1 ;;
  esac
  host="${url#https://}"
  host="${host%%/*}"
  host="${host%:8543}"
  status=$(curl --noproxy '*' --silent --show-error \
    --cacert "$VERA_CA" --resolve "$host:8543:127.0.0.1" \
    -H 'Authorization: Bearer vera-local' \
    -X "$method" "$url" "$@" \
    -D "$AUDIT_TMP/headers" -o "$AUDIT_TMP/body" -w '%{http_code}') || return
  DATA_RESPONSE=$(cat "$AUDIT_TMP/body")
  printf 'HTTP %s\n%s\n' "$status" "$DATA_RESPONSE"
  case "$status" in 2??) ;; *) return 1 ;; esac
}

# Polls the operation URL from the last successful management change, even
# after HTTP 200 or 201. Don't replace it with a fixed sleep.
data_wait_arm() {
  local operation attempt status state delay
  operation=$(awk 'BEGIN {IGNORECASE=1} tolower($1)=="azure-asyncoperation:" {gsub("\r", "", $2); print $2; exit}' "$AUDIT_TMP/headers")
  if [ -z "$operation" ]; then
    operation=$(awk 'tolower($1)=="location:" {gsub("\r", "", $2); print $2; exit}' "$AUDIT_TMP/headers")
  fi
  [ -z "$operation" ] && return 0
  case "$operation" in "$ARM"/_vera/operations/*) ;; *) printf 'Inspect unexpected operation URL: %s\n' "$operation" >&2; return 1 ;; esac
  for attempt in $(seq 1 60); do
    data_request GET "$operation" || return
    status=$(awk '/^HTTP\// {code=$2} END {print code}' "$AUDIT_TMP/headers")
    state=$(printf '%s' "$DATA_RESPONSE" | jq -r '.status // empty' 2>/dev/null) || state=''
    case "$state" in
      Failed|Canceled|Cancelled) return 1 ;;
      Succeeded) return 0 ;;
      InProgress|Running|Accepted) ;;
      *) [ "$status" != '202' ] && return 0 ;;
    esac
    delay=$(awk 'tolower($1)=="retry-after:" {gsub("\r", "", $2); print $2; exit}' "$AUDIT_TMP/headers")
    case "$delay" in ''|*[!0-9]*) delay=1 ;; esac
    sleep "$delay"
  done
  printf 'Operation did not finish within the polling limit\n' >&2
  return 1
}

data_arm() {
  local method="$1" path="$2"
  shift 2
  data_request "$method" "$ARM$path" "$@" || return
  case "$method" in PUT|PATCH|POST|DELETE) data_wait_arm ;; esac
}

The health check answers {"cloud": "azure", "generation_status": "generated", "status": "ok"}. Requests go only to the emulator at https://localhost:8543: the helper refuses any other address, including the Azure-looking URLs some responses hold. When you've finished, close the terminal and delete the scratch directory; that removes only these local files, not what you created in the emulator.

Create clusters and databases through Resource Manager, then use the listed access keys with the local Redis engine over TLS. The examples use the Microsoft.Cache/redisEnterprise management API at 2026-09-01 and resource groups at 2025-04-01, the versions tested with this build: keep them as shown. This is Azure Managed Redis, not the classic Microsoft.Cache/Redis resource. Management requests go to https://localhost:8543. Redis commands go to the local engine at localhost, port 10000, which the Vera launcher publishes. It accepts TLS only, so they need a redis-cli built with TLS support. TLS is checked against the emulator’s certificate, which the setup above saves as $VERA_CA_CERT. The cluster’s host name, azdataredis.eastus.managedredis.localhost, is a value on its record: the example doesn’t connect to it.

Example

Create a cluster and its default database, read both, list the database’s access keys and use one with redis-cli, then delete them.

Create the resource group the examples share, then the cluster, and read the cluster. The cluster answers HTTP 201 while it’s still being created, with an operation to poll. data_arm prints each response, then polls the operation until it has succeeded (long-running operations). That matters here: a database created before the cluster had finished answered HTTP 409 with OperationInProgress.

data_arm PUT "$ROOT?api-version=2025-04-01" \
  -H 'Content-Type: application/json' --data '{"location":"eastus"}'
REDIS="$ROOT/providers/Microsoft.Cache/redisEnterprise/azdataredis"
data_arm PUT "$REDIS?api-version=2026-09-01" -H 'Content-Type: application/json' \
  --data '{"location":"eastus","sku":{"name":"Balanced_B0"},"properties":{"highAvailability":"Disabled","minimumTlsVersion":"1.2","publicNetworkAccess":"Enabled"}}'
data_arm GET "$REDIS?api-version=2026-09-01"

The create needs publicNetworkAccess: without it, it answers HTTP 400 with InvalidRequestContent. The GET answers HTTP 200 with the cluster. These are selected fields:

Output (selected fields)

{
  "name": "azdataredis",
  "properties": {
    "hostName": "azdataredis.eastus.managedredis.localhost"
  }
}

Create the database with the Encrypted client protocol and access key authentication enabled, read it and list its keys:

data_arm PUT "$REDIS/databases/default?api-version=2026-09-01" \
  -H 'Content-Type: application/json' \
  --data '{"properties":{"clientProtocol":"Encrypted","port":10000,"clusteringPolicy":"OSSCluster","evictionPolicy":"AllKeysLRU","accessKeysAuthentication":"Enabled"}}'
data_arm GET "$REDIS/databases/default?api-version=2026-09-01"
data_arm POST "$REDIS/databases/default/listKeys?api-version=2026-09-01"

The create answers HTTP 201 and the GET HTTP 200. Listing the keys answers HTTP 200 with a generated primary and secondary key.

Run the next commands straight after listKeys: they read the primary key from DATA_RESPONSE, which the helper’s next call replaces. redis-cli signs in with that key over TLS, then sets, reads and deletes a key:

export REDISCLI_AUTH="$(printf '%s' "$DATA_RESPONSE" | jq -r '.primaryKey')"
redis-cli --no-auth-warning --tls --cacert "$VERA_CA_CERT" -h localhost -p 10000 PING
redis-cli --no-auth-warning --tls --cacert "$VERA_CA_CERT" -h localhost -p 10000 SET vera:docs:probe hello
redis-cli --no-auth-warning --tls --cacert "$VERA_CA_CERT" -h localhost -p 10000 GET vera:docs:probe
redis-cli --no-auth-warning --tls --cacert "$VERA_CA_CERT" -h localhost -p 10000 DEL vera:docs:probe
unset REDISCLI_AUTH

The four commands answer PONG, OK, hello and 1, the number of keys deleted. Redis 7.0.15 answered. Caches share one keyspace in the emulator, so give each key a name of its own, as vera:docs:probe is here: see Limitations. unset removes the key from your shell.

To clean up, delete the database, then the cluster:

data_arm DELETE "$REDIS/databases/default?api-version=2026-09-01"
data_arm DELETE "$REDIS?api-version=2026-09-01"

Each delete answers HTTP 202, and its operation succeeds. A GET of the cluster then answers HTTP 404. The resource group azdata-rg stays, since deleting a group fails in Vera 1.2.2: see deleting resource groups. Other pages’ examples reuse it. To remove it and anything else left over, start a fresh emulator: see Stop and start again.

Supported features

• Clusters: a Balanced_B0 cluster created, read back with its host name, listed in its resource group and deleted. A missing cluster answers HTTP 404, and a create without publicNetworkAccess answers HTTP 400.
• Databases: the default database created with the Encrypted protocol, port 10000, OSSCluster clustering, AllKeysLRU eviction and access key authentication enabled, read back and deleted.
• Access keys: listKeys returns a generated primary and secondary key.
• Redis over TLS: on Vera 1.2.2, redis-cli signed in with the primary key over TLS on localhost:10000 and ran PING, SET, GET and DEL. Redis 7.0.15 answered.
• Long-running operations: each create and delete returned an operation that the helper polled to Succeeded. Before the cluster’s operation had finished, reading the cluster answered HTTP 404 and creating the database HTTP 409.
• Not run as examples: updating clusters and databases, regenerating keys, import and export, flushing, geo-replication, access policy assignments, migrations, private endpoints and the rest of the management API. The API coverage marks these from a review of Vera 1.2.0’s source, with their limits in the notes.

Limitations

The main limits are below. A few more apply to every service, and the API coverage notes cover smaller differences.

• Caches share one keyspace. From a review of the source, every cache is served by the same local Redis engine and keyspace, so caches aren’t isolated from each other. Use key names no other cache uses, and don’t rely on separate caches to keep data apart.
• TLS only. The local engine on port 10000 accepts TLS connections only, so the example’s database uses the Encrypted protocol, and redis-cli needs --tls and the emulator’s certificate.
• Only basic commands were run. On Vera 1.2.2, PING, SET, GET and DEL worked with the primary key. Clustering, eviction, persistence and failover weren’t established, and the database’s clustering, eviction and high-availability settings weren’t shown to take effect.
• Keys were checked with access key authentication enabled. The example sets accessKeysAuthentication to Enabled. In Vera 1.2.0 preview, a database created without it read back Disabled, and signing in with the keys that way wasn’t tested.
• Import, export, flush and force-link act on local snapshots. Databases_Import, Databases_Export, Databases_Flush and Databases_ForceLinkToReplicationGroup work on the emulator’s private database and transfer snapshots. An attached Redis keyspace and RDB file transfer to or from external storage aren’t established. Migrations_Start needs an existing local snapshot of the database.

API coverage

Every operation of the API on this page, from its pinned public definition, and whether Vera 1.2.0 implements it. Only the API surfaces in this release are listed, and each operation once. Implementation availability was reviewed against the Vera 1.2.0 source on 6 November 2026. Source inspection identifies a local implementation and its known limits; it doesn't mean every operation or API version was tested with a request. Each note names its evidence: a Local observation without a build or date is from Vera 1.2.0 preview, on 5 November 2026, and one from a later build, such as Vera 1.2.0-rc.3 or Vera 1.2.2, names that build and its date. No response was compared with Azure's. What the statuses mean

AccessPolicyAssignment

4 of 4 implemented

Operation	Status	Notes
AccessPolicyAssignment_CreateUpdate	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
AccessPolicyAssignment_Delete	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
AccessPolicyAssignment_Get	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
AccessPolicyAssignment_List	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.

Clusters

1 of 1 implemented

Operation	Status	Notes
Clusters_UnlinkMigratedEndpoint	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.

Databases

13 of 13 implemented · 4 known differences

Operation	Status	Notes
Databases_Create	Implemented	Local observation: Created the default database (HTTP 201) once the cluster's operation had finished. Sent before then, it answered HTTP 409 OperationInProgress.
Databases_Delete	Implemented	Local observation: Deleted the database (HTTP 202), and its operation reached Succeeded.
Databases_Export	Known difference	Source inspection: Acts on the emulator's private database and transfer snapshots; keyspace sync with an attached Redis engine isn't established. Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Databases_Flush	Known difference	Source inspection: Acts on the emulator's private database and transfer snapshots; keyspace sync with an attached Redis engine isn't established. Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Databases_ForceLinkToReplicationGroup	Known difference	Source inspection: Acts on the emulator's private database and transfer snapshots; keyspace sync with an attached Redis engine isn't established. Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Databases_ForceUnlink	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Databases_Get	Implemented	Local observation: Returned the database (HTTP 200) once its create operation had finished; before then it answered HTTP 404.
Databases_Import	Known difference	Source inspection: Acts on the emulator's private database and transfer snapshots; keyspace sync with an attached Redis engine isn't established. Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Databases_ListByCluster	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Databases_ListKeys	Implemented	Local observation: Vera 1.2.2, 8 November 2026 — on a database created with the Encrypted client protocol and accessKeysAuthentication Enabled, redis-cli signed in with the returned primary key over TLS at localhost:10000; PING, SET, GET and DEL answered PONG, OK, hello and 1, from Redis 7.0.15. Earlier, in Vera 1.2.0 preview, the request returned generated primary and secondary keys (HTTP 200) once the database's operation had finished, and HTTP 404 before then.
Databases_RegenerateKey	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Databases_Update	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Databases_UpgradeDBRedisVersion	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.

Migrations

6 of 6 implemented · 1 known difference

Operation	Status	Notes
Migrations_Get	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Migrations_List	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Migrations_Start	Known difference	Source inspection: Starts a migration from the emulator's private database snapshots, so it needs an existing local snapshot; keyspace sync with an attached Redis engine isn't established. Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Migrations_Undo	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Migrations_UnlinkMigratedEndpoint	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
Migrations_Validate	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.

Operations

1 of 1 implemented

Operation	Status	Notes
Operations_List	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.

OperationsStatus

1 of 1 implemented

Operation	Status	Notes
OperationsStatus_Get	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.

PrivateEndpointConnections

4 of 4 implemented

Operation	Status	Notes
PrivateEndpointConnections_Delete	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
PrivateEndpointConnections_Get	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
PrivateEndpointConnections_List	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
PrivateEndpointConnections_Put	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.

PrivateLinkResources

1 of 1 implemented

Operation	Status	Notes
PrivateLinkResources_ListByCluster	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.

RedisEnterprise

7 of 7 implemented

Operation	Status	Notes
RedisEnterprise_Create	Implemented	Local observation: Created a Balanced_B0 cluster (HTTP 201) that was still being created, with an operation to poll. Without publicNetworkAccess, the create answered HTTP 400 InvalidRequestContent.
RedisEnterprise_Delete	Implemented	Local observation: Deleted the cluster (HTTP 202); its operation reached Succeeded, and a GET then answered HTTP 404.
RedisEnterprise_Get	Implemented	Local observation: Returned the cluster with host name azdataredis.eastus.managedredis.localhost (HTTP 200) once its create operation had finished; before then it answered HTTP 404. A missing cluster, and the cluster after deletion, answered HTTP 404.
RedisEnterprise_List	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
RedisEnterprise_ListByResourceGroup	Implemented	Local observation: Listed the resource group's clusters (HTTP 200).
RedisEnterprise_ListSkusForScaling	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.
RedisEnterprise_Update	Implemented	Source inspection: Local Redis Enterprise management; replication, import, export and version changes use local snapshots, and RDB file transfer isn't established.