Útmutatás szabályozott kérelmekhez az Azure Resource Graph-ban
Az Azure Resource Graph-adatok programozott és gyakori használata során figyelembe kell venni, hogy a szabályozás hogyan befolyásolja a lekérdezések eredményeit. Az adatok kérésének módosítása segíthet Önnek és a szervezetnek elkerülni a szabályozást, és fenntartani az Azure-erőforrásokra vonatkozó időalapú adatok áramlását.
Ez a cikk négy olyan területet és mintát mutat be, amelyek a lekérdezések Azure Resource Graph-ban való létrehozásával kapcsolatosak:
- A szabályozás fejléceinek ismertetése.
- Lekérdezések csoportosítása.
- Megdöbbentő lekérdezések.
- A lapozás hatása.
Understand throttling headers
Azure Resource Graph allocates a quota number for each user based on a time window. A felhasználók például 5 másodpercenként legfeljebb 15 lekérdezést küldhetnek szabályozás nélkül. A kvóta értékét számos tényező határozza meg, és változhat.
In every query response, Azure Resource Graph adds two throttling headers:
x-ms-user-quota-remaining
(int): A felhasználó fennmaradó erőforráskvótája. Ez az érték a lekérdezések számának megfeleltetésére van leképzve.x-ms-user-quota-resets-after
(óó:mm:ss): A felhasználó kvótahasználatának alaphelyzetbe állításáig eltelt idő.
Ha egy biztonsági tag több mint 10 000 előfizetéshez fér hozzá a bérlői vagy felügyeleti csoport lekérdezési hatókörében, a válasz az első 10 000 előfizetésre korlátozódik, és a fejlécet true
a x-ms-tenant-subscription-limit-hit
rendszer visszaadja.
A fejlécek működésének szemléltetéséhez tekintsünk meg egy lekérdezési választ, amelynek fejléce x-ms-user-quota-remaining: 10
és értéke és x-ms-user-quota-resets-after: 00:00:03
értéke.
- A következő 3 másodpercben legfeljebb 10 lekérdezés küldhető el szabályozás nélkül.
- 3 másodpercen belül a rendszer visszaállítja és visszaállítja
x-ms-user-quota-remaining
x-ms-user-quota-resets-after
15
00:00:05
az értékeket.
Ha egy példát szeretne látni arra, hogyan használhatja a fejléceket a lekérdezési kérések visszalépésére , tekintse meg a lekérdezésben található mintát párhuzamosan.
Grouping queries
A lekérdezések előfizetés, erőforráscsoport vagy egyéni erőforrás szerinti csoportosítása hatékonyabb, mint a lekérdezések párhuzamosítása. The quota cost of a larger query is often less than the quota cost of many small and targeted queries. A csoport mérete 300-nál kisebbnek ajánlott.
Példa a rosszul optimalizált megközelítésre.
// NOT RECOMMENDED var header = /* your request header */ var subscriptionIds = /* A big list of subscriptionIds */ foreach (var subscriptionId in subscriptionIds) { var userQueryRequest = new QueryRequest( subscriptions: new[] { subscriptionId }, query: "Resoures | project name, type"); var azureOperationResponse = await this.resourceGraphClient .ResourcesWithHttpMessagesAsync(userQueryRequest, header) .ConfigureAwait(false); // ... }
Példa az optimalizált csoportosítási megközelítésre.
// RECOMMENDED var header = /* your request header */ var subscriptionIds = /* A big list of subscriptionIds */ const int groupSize = 100; for (var i = 0; i <= subscriptionIds.Count / groupSize; ++i) { var currSubscriptionGroup = subscriptionIds.Skip(i * groupSize).Take(groupSize).ToList(); var userQueryRequest = new QueryRequest( subscriptions: currSubscriptionGroup, query: "Resources | project name, type"); var azureOperationResponse = await this.resourceGraphClient .ResourcesWithHttpMessagesAsync(userQueryRequest, header) .ConfigureAwait(false); // ... }
Példa egy optimalizált csoportosítási módszerre, amely több erőforrást kér le egy lekérdezésben.
Resources | where id in~ ({resourceIdGroup}) | project name, type
// RECOMMENDED var header = /* your request header */ var resourceIds = /* A big list of resourceIds */ const int groupSize = 100; for (var i = 0; i <= resourceIds.Count / groupSize; ++i) { var resourceIdGroup = string.Join(",", resourceIds.Skip(i * groupSize).Take(groupSize).Select(id => string.Format("'{0}'", id))); var userQueryRequest = new QueryRequest( subscriptions: subscriptionList, query: $"Resources | where id in~ ({resourceIdGroup}) | project name, type"); var azureOperationResponse = await this.resourceGraphClient .ResourcesWithHttpMessagesAsync(userQueryRequest, header) .ConfigureAwait(false); // ... }
Staggering queries
Because of the way throttling is enforced, we recommend queries to be staggered. Például ahelyett, hogy egyszerre 60 lekérdezést küldene, a lekérdezéseket négy 5 másodperces ablakba bonthatja.
Nem átmeneti lekérdezés ütemezése.
Lekérdezések száma 60 0 0 0 Időintervallum (mp) 0-5 5-10 10-15 15-20 Átmeneti lekérdezés ütemezése.
Lekérdezések száma 15 15 15 15 Időintervallum (mp) 0-5 5-10 10-15 15-20
Az alábbi kód egy példa a fejlécek szabályozásának tiszteletben tartására az Azure Resource Graph lekérdezése során.
while (/* Need to query more? */)
{
var userQueryRequest = /* ... */
// Send post request to Azure Resource Graph
var azureOperationResponse = await this.resourceGraphClient
.ResourcesWithHttpMessagesAsync(userQueryRequest, header)
.ConfigureAwait(false);
var responseHeaders = azureOperationResponse.response.Headers;
int remainingQuota = /* read and parse x-ms-user-quota-remaining from responseHeaders */
TimeSpan resetAfter = /* read and parse x-ms-user-quota-resets-after from responseHeaders */
if (remainingQuota == 0)
{
// Need to wait until new quota is allocated
await Task.Delay(resetAfter).ConfigureAwait(false);
}
}
Lekérdezés párhuzamosan
Annak ellenére, hogy a csoportosítás párhuzamosítással javasolt, vannak olyan esetek, amikor a lekérdezések nem csoportosíthatók könnyen. Ezekben az esetekben érdemes lehet több lekérdezés párhuzamos elküldésével lekérdezni az Azure Resource Graphot. Az alábbi példa bemutatja, hogyan lehet visszalépést elvégezni a szabályozás fejlécei alapján.
IEnumerable<IEnumerable<string>> queryGroup = /* Groups of queries */
// Run groups in parallel.
await Task.WhenAll(queryGroup.Select(ExecuteQueries)).ConfigureAwait(false);
async Task ExecuteQueries(IEnumerable<string> queries)
{
foreach (var query in queries)
{
var userQueryRequest = new QueryRequest(
subscriptions: subscriptionList,
query: query);
// Send post request to Azure Resource Graph.
var azureOperationResponse = await this.resourceGraphClient
.ResourcesWithHttpMessagesAsync(userQueryRequest, header)
.ConfigureAwait(false);
var responseHeaders = azureOperationResponse.response.Headers;
int remainingQuota = /* read and parse x-ms-user-quota-remaining from responseHeaders */
TimeSpan resetAfter = /* read and parse x-ms-user-quota-resets-after from responseHeaders */
if (remainingQuota == 0)
{
// Delay by a random period to avoid bursting when the quota is reset.
var delay = (new Random()).Next(1, 5) * resetAfter;
await Task.Delay(delay).ConfigureAwait(false);
}
}
}
Pagination
Mivel az Azure Resource Graph legfeljebb 1000 bejegyzést ad vissza egyetlen lekérdezési válaszban, előfordulhat, hogy a lekérdezéseket többoldalasra kell helyeznie a kívánt teljes adatkészlet lekéréséhez. Egyes Azure Resource Graph-ügyfelek azonban másként kezelik a lapozást, mint mások.
A ResourceGraph SDK használatakor a lapozást úgy kell kezelnie, hogy az előző lekérdezési válaszból visszaadott kihagyó jogkivonatot átadja a következő lapszámozott lekérdezésnek. Ez a kialakítás azt jelenti, hogy az összes lapszámozott hívás eredményét össze kell gyűjtenie, és a végén össze kell egyesítenie őket. Ebben az esetben minden elküldött lapszámozott lekérdezés egy lekérdezési kvótát vesz igénybe.
var results = new List<object>();
var queryRequest = new QueryRequest(
subscriptions: new[] { mySubscriptionId },
query: "Resources | project id, name, type");
var azureOperationResponse = await this.resourceGraphClient
.ResourcesWithHttpMessagesAsync(queryRequest, header)
.ConfigureAwait(false);
while (!string.IsNullOrEmpty(azureOperationResponse.Body.SkipToken))
{
queryRequest.Options ??= new QueryRequestOptions();
queryRequest.Options.SkipToken = azureOperationResponse.Body.SkipToken;
var azureOperationResponse = await this.resourceGraphClient
.ResourcesWithHttpMessagesAsync(queryRequest, header)
.ConfigureAwait(false);
results.Add(azureOperationResponse.Body.Data.Rows);
// Inspect throttling headers in query response and delay the next call if needed.
}
Még mindig szabályozva van?
Ha a cikk ajánlásait használta, és az Azure Resource Graph-lekérdezések szabályozása még folyamatban van, forduljon az Azure Resource Graph csapatához. A csapat támogatja az Azure Resource Graphot, de nem támogatja a Microsoft Graph szabályozását.
Adja meg ezeket a részleteket, amikor kapcsolatba lép az Azure Resource Graph csapatával:
- Az adott használati esetnek és üzleti illesztőprogramnak magasabb szabályozási korlátra van szüksége.
- Hány erőforráshoz rendelkezik hozzáféréssel? Hányat adnak vissza egyetlen lekérdezésből?
- Milyen típusú erőforrások érdeklik?
- Mi a lekérdezési minta? X lekérdezések Y másodpercenként és így tovább.
További lépések
- Tekintse meg a kezdő lekérdezésekben használt nyelvet.
- A speciális lekérdezések speciális felhasználási módjai.
- További információ az erőforrások felfedezéséről.