Mi az elosztott nyomkövetés és a telemetriai korreláció?

  • Cikk

Feljegyzés

Az alábbi dokumentáció az Alkalmazás Elemzések klasszikus API-ra támaszkodik. Az Alkalmazás Elemzések hosszú távú terve az Adatok gyűjtése Az OpenTelemetria használatával. További információ: Az Azure Monitor OpenTelemetria engedélyezése .NET-, Node.js-, Python- és Java-alkalmazásokhoz.

A modern felhő- és mikroszolgáltatás-architektúrák egyszerű, egymástól függetlenül üzembe helyezhető szolgáltatásokat tettek lehetővé, amelyek csökkentik a költségeket, miközben növelik a rendelkezésre állást és az átviteli sebességet. Ez azonban megnehezítette az általános rendszerek érvelését és hibakeresését. Az elosztott nyomkövetés egy olyan teljesítményprofilozóval oldja meg ezt a problémát, amely a felhő- és mikroszolgáltatás-architektúrák hívásveremeihez hasonlóan működik.

Az Azure Monitor két szolgáltatást biztosít az elosztott nyomkövetési adatok használatához: az egyetlen tranzakció/kérelem tranzakciódiagnosztikai nézetét és az alkalmazástérkép nézetet, amely a rendszerek interakcióit mutatja be.

Az alkalmazás Elemzések külön monitorozza az egyes összetevőket, és elosztott telemetriai korreláció használatával észleli, hogy melyik összetevő felelős a hibákért vagy a teljesítménycsökkenésért. Ez a cikk az alkalmazás Elemzések által használt különböző nyelveken és platformokon alkalmazott adatmodellt, környezetpropagálási technikákat, protokollokat és a korrelációs taktikák implementálását ismerteti.

Elosztott nyomkövetés engedélyezése

Az alkalmazások elosztott nyomkövetésének engedélyezéséhez adja hozzá a megfelelő ügynököt, SDK-t vagy tárat az egyes szolgáltatásokhoz a programozási nyelv alapján.

Engedélyezés alkalmazáson keresztül Elemzések automatikus beléptetéssel vagy SDK-kkal

Az alkalmazás Elemzések ügynökök és SDK-k a .NET, a .NET Core, a Java, a Node.js és a JavaScript esetében mind támogatják az elosztott nyomkövetést natív módon. Az egyes alkalmazások Elemzések SDK telepítésére és konfigurálására vonatkozó utasítások a következőkhöz érhetők el:

A megfelelő alkalmazás Elemzések SDK telepítésével és konfigurálásával a rendszer automatikusan gyűjti a nyomkövetési információkat a népszerű keretrendszerekhez, kódtárakhoz és technológiákhoz az SDK függőségi autoklektorai által. A támogatott technológiák teljes listája elérhető a Dependency autocollection dokumentációjában.

Bármely technológia manuálisan is nyomon követhető a TelemetryClient TrackDependencyhívásával.

Engedélyezés OpenTelemetry használatával

Az alkalmazás Elemzések mostantól támogatja az elosztott nyomkövetést az OpenTelemetria segítségével. Az OpenTelemetria szállítósemleges kialakítást biztosít a nyomkövetések, metrikák és naplók alkalmazás Elemzések való küldéséhez. Az OpenTelemetry-közösség kezdetben az elosztott nyomkövetést vette igénybe. A metrikák és a naplók még folyamatban vannak.

A teljes megfigyelhetőségi történet mindhárom pillért tartalmazza. Az Azure Monitor OpenTelemetry-alapú ajánlataink állapotának ellenőrzéséhez tekintse meg a legújabb állapotot a benne foglalt ajánlatokról, az általánosan elérhető ajánlatokról és a támogatási lehetőségekről.

Az alábbi oldalak nyelvi útmutatást nyújtanak a Microsoft OpenTelemetry-alapú ajánlatainak engedélyezéséhez és konfigurálásához. Fontos, hogy megosztjuk az egyes ajánlatok elérhető funkcióit és korlátait, hogy megállapíthassa, az OpenTelemetria megfelelő-e a projekthez.

Engedélyezés az OpenCensuson keresztül

Az Alkalmazás Elemzések SDK-k mellett az Alkalmazás Elemzések az OpenCensuson keresztüli elosztott nyomkövetést is támogatja. Az OpenCensus egy nyílt forráskódú, szállítói-agnosztikus kódtár-disztribúció, amely metrikák gyűjtését és elosztott nyomkövetést biztosít a szolgáltatások számára. Emellett lehetővé teszi a nyílt forráskódú közösség számára az elosztott nyomkövetést olyan népszerű technológiákkal, mint a Redis, a Memcached vagy a MongoDB. A Microsoft számos más monitorozási és felhőpartnerrel együttműködik az OpenCensuson.

A Pythonhoz készült OpenCensusról további információt az Azure Monitor beállítása a Python-alkalmazáshoz című témakörben talál.

Az OpenCensus webhelye api-referenciadokumentációt tart fenn a Pythonhoz, a Go-hoz és az OpenCensus használatához szükséges különböző útmutatókhoz.

Adatmodell telemetriai korrelációhoz

Az alkalmazás Elemzések definiál egy adatmodellt az elosztott telemetriai korrelációhoz. Ha a telemetriát logikai művelethez szeretné társítani, minden telemetriai elemhez tartozik egy környezetmező.operation_Id Az elosztott nyomkövetés minden telemetriai eleme megosztja ezt az azonosítót. Így akkor is társíthat más összetevők által jelentett telemetriát, ha egyetlen rétegből veszíti el a telemetriát.

Az elosztott logikai műveletek általában kisebb műveletekből állnak, amelyeket az egyik összetevő feldolgoz. A kérelemtelemetria határozza meg ezeket a műveleteket. Minden kérelemtelemetriaelem saját id , amely egyedileg és globálisan azonosítja azt. A kérelemhez társított összes telemetriai elemnek (például nyomkövetésnek és kivételnek) a kérelem idértékére kell állítaniaoperation_parentId.

A függőségi telemetria minden kimenő műveletet jelöl, például egy másik összetevőhöz irányuló HTTP-hívást. Azt is meghatározza, hogy a saját id , amely globálisan egyedi. A függőségi hívás által kezdeményezett kérelemtelemetria ezt id használja annak operation_parentId.

Az elosztott logikai művelet nézetét a következővel operation_Idhozhatja létre: . operation_parentIdrequest.iddependency.id Ezek a mezők a telemetriai hívások oksági sorrendjét is meghatározzák.

Mikroszolgáltatási környezetben az összetevőkből származó nyomkövetések különböző tárolóelemekre is áttérhetnek. Minden összetevőnek saját kapcsolati sztring lehet az Alkalmazás Elemzések. A logikai művelet telemetriájának lekéréséhez az alkalmazás Elemzések minden tárolóelemből lekérdezi az adatokat.

Ha a tárelemek száma nagy, tippet kell adnia arról, hogy hol keresse a következőt. Az alkalmazás Elemzések adatmodell két mezőt határoz meg a probléma megoldásához: request.source ésdependency.target. Az első mező azonosítja a függőségi kérelmet kezdeményező összetevőt. A második mező azonosítja, hogy melyik összetevő válaszolt a függőségi hívásra.

További információ a több különálló példányból a app lekérdezési kifejezés használatával történő lekérdezésről: app() kifejezés az Azure Monitor-lekérdezésben.

Példa

Lássunk egy példát. A Stock Prices nevű alkalmazás egy részvény aktuális piaci árát jeleníti meg egy Stock nevű külső API használatával. A Tőzsdei árak alkalmazásnak van egy Stock lap nevű oldala, amelyet az ügyfél webböngészője a segítségével GET /Home/Stocknyit meg. Az alkalmazás HTTP-hívással GET /api/stock/valuelekérdezi a Stock API-t.

Az eredményként kapott telemetriát egy lekérdezés futtatásával elemezheti:

(requests | union dependencies | union pageViews)
| where operation_Id == "STYz"
| project timestamp, itemType, name, id, operation_ParentId, operation_Id

Az eredményekben az összes telemetriaelem osztozik a gyökérben operation_Id. Amikor Ajax-hívást kezdeményez a lapról, a rendszer egy új egyedi azonosítót (qJSXU) rendel a függőségi telemetriahoz, és a pageView azonosítóját operation_ParentIdhasználja a rendszer. A kiszolgálókérés ezután az Ajax-azonosítót használja a következőként operation_ParentId: .

Itemtype név ID (Azonosító) operation_ParentId operation_Id
pageView Stock page STYz STYz
Függőség GET /Home/Stock qJSXU STYz STYz
kérés GET Home/Stock KqKwlrSt9PA= qJSXU STYz
Függőség GET /api/stock/value bBrf2L7mm2g= KqKwlrSt9PA= STYz

Amikor a hívást GET /api/stock/value egy külső szolgáltatáshoz intézik, ismernie kell a kiszolgáló identitását, hogy megfelelően be tudja állítani a dependency.target mezőt. Ha a külső szolgáltatás nem támogatja a figyelést, target a szolgáltatás állomásnevére van állítva. Például: stock-prices-api.com. Ha azonban a szolgáltatás egy előre definiált HTTP-fejléc visszaadásával azonosítja magát, tartalmazza azt a szolgáltatásidentitást, target amely lehetővé teszi, hogy az alkalmazás Elemzések elosztott nyomkövetést hozzon létre a szolgáltatásból származó telemetriai adatok lekérdezésével.

Korrelációs fejlécek a W3C TraceContext használatával

Az alkalmazás Elemzések a W3C Trace-Contextre vált, amely a következőket határozza meg:

  • traceparent: A hívás globálisan egyedi műveleti azonosítóját és egyedi azonosítóját hordozza.
  • tracestate: Rendszerspecifikus nyomkövetési környezetet hordoz.

Az Alkalmazás Elemzések SDK legújabb verziója támogatja a Trace-Context protokollt, de előfordulhat, hogy be kell jelentkeznie. (Az alkalmazás Elemzések SDK által támogatott korábbi korrelációs protokolllal való visszamenőleges kompatibilitás megmarad.)

A korrelációs HTTP protokoll, más néven Request-Id elavult. Ez a protokoll két fejlécet határoz meg:

  • Request-Id: A hívás globálisan egyedi azonosítóját hordozza.
  • Correlation-Context: Az elosztott nyomkövetési tulajdonságok név-érték párok gyűjteményét hordozza.

Az alkalmazás Elemzések a korrelációs HTTP protokoll bővítményét is meghatározza. Név-érték párok használatával Request-Context propagálja az azonnali hívó vagy hívó által használt tulajdonságok gyűjteményét. Az Alkalmazás Elemzések SDK ezzel a fejléccel állítja be a mezőket és request.source a dependency.target mezőket.

A W3C Trace-Context és az Application Elemzések adatmodellek leképezése a következő módon:

Application Insights W3C TraceContext
Idés RequestDependency parent-id
Operation_Id nyomkövetési azonosító
Operation_ParentId a span szülőazonosítója . Ennek a mezőnek üresnek kell lennie, ha gyökértartományról van szó.

További információ: Application Elemzések telemetria adatmodell.

W3C elosztott nyomkövetés támogatásának engedélyezése .NET-alkalmazásokhoz

A W3C TraceContext-alapú elosztott nyomkövetés alapértelmezés szerint engedélyezve van az összes legutóbbi .NET-keretrendszer/.NET Core SDK-ban, valamint az örökölt Request-Id protokolllal való visszamenőleges kompatibilitással.

A W3C elosztott nyomkövetés támogatásának engedélyezése Java-alkalmazásokhoz

Java 3.0-ügynök

A Java 3.0-ügynök támogatja a W3C-t a dobozon kívül, és nincs szükség további konfigurációra.

Java SDK

  • Bejövő konfiguráció

    Java-Enterprise kiadás-alkalmazások esetén adja hozzá a következő kódot az <TelemetryModules> alkalmazás címkéjére Elemzések.xml:

    <Add type="com.microsoft.applicationinsights.web.extensibility.modules.WebRequestTrackingTelemetryModule>
   <Param name = "W3CEnabled" value ="true"/>
   <Param name ="enableW3CBackCompat" value = "true" />
</Add>

    Spring Boot-alkalmazások esetén adja hozzá az alábbi tulajdonságokat:

    • azure.application-insights.web.enable-W3C=true
    • azure.application-insights.web.enable-W3C-backcompat-mode=true

  • Kimenő konfiguráció

    Adja hozzá a következő kódot a AI-Agent.xml:

    <Instrumentation>
  <BuiltIn enabled="true">
    <HTTP enabled="true" W3C="true" enableW3CBackCompat="true"/>
  </BuiltIn>
</Instrumentation>

    Feljegyzés

    A visszamenőleges kompatibilitási mód alapértelmezés szerint engedélyezve van, és a enableW3CBackCompat paraméter nem kötelező. Csak akkor használja, ha ki szeretné kapcsolni a visszamenőleges kompatibilitást.

    Ideális esetben kikapcsolhatja ezt a módot, ha az összes szolgáltatás a W3C protokollt támogató SDK-k újabb verzióira frissül. Javasoljuk, hogy a lehető leghamarabb lépjen ezekre az újabb SDK-kra.

Fontos, hogy a bejövő és kimenő konfigurációk pontosan azonosak legyenek.

W3C elosztott nyomkövetés támogatásának engedélyezése webalkalmazásokhoz

Ez a funkció alapértelmezés szerint engedélyezve van a JavaScripthez, és a fejlécek automatikusan bekerülnek, ha az üzemeltetési lap tartománya megegyezik azzal a tartománnyal, amelybe a kéréseket küldi (például a tárhelyoldal és example.com az Ajax-kérelmek küldése example.com). Az elosztott nyomkövetési mód módosításához használja a distributedTracingMode konfigurációs mezőt. AI_AND_W3C alapértelmezés szerint az Alkalmazás Elemzések által létrehozott örökölt szolgáltatásokkal való visszamenőleges kompatibilitás érdekében van megadva.

Ha az XMLHttpRequest vagy a Fetch Ajax-kérelmeket egy másik tartománygazda továbbítja, beleértve az altartományokat is, a korrelációs fejlécek alapértelmezés szerint nem jelennek meg. A funkció engedélyezéséhez állítsa a konfigurációs mezőt a enableCorsCorrelation következőretrue: . Ha be truevan állítvaenableCorsCorrelation, minden XMLHttpRequest és Fetch Ajax-kérés tartalmazza a korrelációs fejléceket. Ennek eredményeképpen, ha a meghívni kívánt kiszolgálón lévő alkalmazás nem támogatja a traceparent fejlécet, a kérés sikertelen lehet attól függően, hogy a böngésző/ verzió érvényesítheti-e a kérést a kiszolgáló által elfogadott fejlécek alapján. A konfigurációs mező használatával correlationHeaderExcludedDomains kizárhatja a kiszolgáló tartományát az összetevők közötti korrelációs fejlécinjektálásból. Például kizárhatja correlationHeaderExcludedDomains: ['*.auth0.com'] a korrelációs fejléceket az Auth0 identitásszolgáltatónak küldött kérelmekből.

Fontos

A korreláció engedélyezéséhez szükséges összes konfiguráció megtekintéséhez tekintse meg a JavaScript korrelációs dokumentációját.

Telemetriai korreláció az OpenCensus Pythonban

Az OpenCensus Python további konfiguráció nélkül támogatja a W3C Trace-Context-t .

Referenciaként az OpenCensus adatmodellt ezen a GitHub-oldalon találja.

Bejövő kérések korrelációja

Az OpenCensus Python korrelálja a W3C Trace-Context fejléceket a bejövő kérésekből a kérésekből létrehozott időtartamokra. Az OpenCensus automatikusan korrelál ezen népszerű webalkalmazás-keretrendszerek integrációjával: Flask, Django és Piramis. A W3C Trace-Context fejléceket csak a megfelelő formátumban kell feltöltenie, és a kéréssel együtt el kell küldenie őket.

Ismerje meg ezt a Flask-mintaalkalmazást. Telepítse a Flaskot, az OpenCensus-t és a Flask és az Azure bővítményeit.


pip install flask opencensus opencensus-ext-flask opencensus-ext-azure

Hozzá kell adnia az alkalmazás Elemzések kapcsolati sztring a környezeti változóhoz.

APPLICATIONINSIGHTS_CONNECTION_STRING=<appinsights-connection-string>

Flask-mintaalkalmazás

from flask import Flask
from opencensus.ext.azure.trace_exporter import AzureExporter
from opencensus.ext.flask.flask_middleware import FlaskMiddleware
from opencensus.trace.samplers import ProbabilitySampler

app = Flask(__name__)
middleware = FlaskMiddleware(
    app,
    exporter=AzureExporter(
        connection_string='<appinsights-connection-string>', # or set environment variable APPLICATION_INSIGHTS_CONNECTION_STRING
    ), 
    sampler=ProbabilitySampler(rate=1.0),
)

@app.route('/')
def hello():
    return 'Hello World!'

if __name__ == '__main__':
    app.run(host='localhost', port=8080, threaded=True)

Ez a kód egy Flask-mintaalkalmazást futtat a helyi gépen, és figyeli a portot 8080. A nyomkövetési környezet korrelációjához küldjön egy kérést a végpontnak. Ebben a példában egy parancsot curl használhat:

curl --header "traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01" localhost:8080

A Trace-Context fejlécformátumának megtekintésével a következő információk származtathatók:

version: 00

trace-id: 4bf92f3577b34da6a3ce929d0e0e4736

parent-id/span-id: 00f067aa0ba902b7

trace-flags: 01

Ha megtekinti az Azure Monitornak küldött kérelembejegyzést, láthatja a nyomkövetési fejléc adataival kitöltött mezőket. Az adatokat az Azure Monitor-alkalmazás Elemzések erőforrás Naplók (Elemzések) területén találja.

Screenshot that shows Request telemetry in Logs (Analytics).

A id mező formátuma <trace-id>.<span-id>trace-id a kérelemben átadott nyomkövetési fejlécből származik, és span-id egy 8 bájtos generált tömb ehhez a tartományhoz.

A operation_ParentId mező formátuma <trace-id>.<parent-id>mindkettő, trace-id és parent-id a kérelemben átadott nyomkövetési fejlécből származik.

Napló-összefüggések

Az OpenCensus Python lehetővé teszi a naplók korrelációját egy nyomkövetési azonosító, egy span ID és egy mintavételezési jelző hozzáadásával a naplórekordokhoz. Ezeket az attribútumokat az OpenCensus naplózási integrációjának telepítésével veheti fel. A következő attribútumok lesznek hozzáadva a Python-objektumokhoz LogRecord : traceId, spanIdés traceSampled (csak az integráció után létrehozott naplózókra vonatkozik).

Telepítse az OpenCensus naplózási integrációját:

python -m pip install opencensus-ext-logging

Mintaalkalmazás

import logging

from opencensus.trace import config_integration
from opencensus.trace.samplers import AlwaysOnSampler
from opencensus.trace.tracer import Tracer

config_integration.trace_integrations(['logging'])
logging.basicConfig(format='%(asctime)s traceId=%(traceId)s spanId=%(spanId)s %(message)s')
tracer = Tracer(sampler=AlwaysOnSampler())

logger = logging.getLogger(__name__)
logger.warning('Before the span')
with tracer.span(name='hello'):
    logger.warning('In the span')
logger.warning('After the span')

A kód futtatásakor a következő nyomatok jelennek meg a konzolon:

2019-10-17 11:25:59,382 traceId=c54cb1d4bbbec5864bf0917c64aeacdc spanId=0000000000000000 Before the span
2019-10-17 11:25:59,384 traceId=c54cb1d4bbbec5864bf0917c64aeacdc spanId=70da28f5a4831014 In the span
2019-10-17 11:25:59,385 traceId=c54cb1d4bbbec5864bf0917c64aeacdc spanId=0000000000000000 After the span

Figyelje meg, hogy a naplóüzenetnek van egy spanId ajándéka, amely a megadott tartományon belül van. Ez spanId ugyanaz, mint ami a nevesített hellotartományhoz tartozik.

A naplóadatokat a következővel AzureLogHandlerexportálhatja: . További információ: Az Azure Monitor beállítása a Python-alkalmazáshoz.

A megfelelő korreláció érdekében nyomkövetési információkat is továbbíthatunk az egyik összetevőről a másikra. Vegyük például azt a forgatókönyvet, amelyben két összetevő van, module1 és module2. Az 1. modul függvényeket hív meg a 2. modulban. Ha mind a kettőből, mind module1module2 egyetlen nyomkövetésből szeretne naplókat lekérni, a következő megközelítést használhatjuk:

# module1.py
import logging

from opencensus.trace import config_integration
from opencensus.trace.samplers import AlwaysOnSampler
from opencensus.trace.tracer import Tracer
from module_2 import function_1

config_integration.trace_integrations(["logging"])
logging.basicConfig(
    format="%(asctime)s traceId=%(traceId)s spanId=%(spanId)s %(message)s"
)
tracer = Tracer(sampler=AlwaysOnSampler())

logger = logging.getLogger(__name__)
logger.warning("Before the span")

with tracer.span(name="hello"):
    logger.warning("In the span")
    function_1(logger, tracer)
logger.warning("After the span")

# module_2.py
import logging

from opencensus.trace import config_integration
from opencensus.trace.samplers import AlwaysOnSampler
from opencensus.trace.tracer import Tracer

config_integration.trace_integrations(["logging"])
logging.basicConfig(
    format="%(asctime)s traceId=%(traceId)s spanId=%(spanId)s %(message)s"
)
logger = logging.getLogger(__name__)
tracer = Tracer(sampler=AlwaysOnSampler())


def function_1(logger=logger, parent_tracer=None):
    if parent_tracer is not None:
        tracer = Tracer(
            span_context=parent_tracer.span_context,
            sampler=AlwaysOnSampler(),
        )
    else:
        tracer = Tracer(sampler=AlwaysOnSampler())

    with tracer.span("function_1"):
        logger.info("In function_1")

Telemetriai korreláció a .NET-ben

Az alkalmazás előkészítésekor a korreláció alapértelmezés szerint kezelhető. Nincs szükség speciális műveletekre.

A .NET-futtatókörnyezet az Activity és a DiagnosticSource segítségével támogatja az elosztott terjesztést

Az alkalmazás Elemzések .NET SDK a telemetriát gyűjti DiagnosticSource és Activity korrelálja.

Telemetriai korreláció Java nyelven

A Java-ügynök támogatja a telemetriai adatok automatikus korrelációját. Automatikusan kitölti operation_id a kérés hatókörében kibocsátott összes telemetriát (például nyomkövetéseket, kivételeket és egyéni eseményeket). A HTTP-en keresztüli szolgáltatásközi hívásokhoz korábban ismertetett korrelációs fejléceket is propagálja, ha a Java SDK-ügynök konfigurálva van.

Feljegyzés

Az alkalmazás Elemzések Java-ügynök automatikusan észleli a JMS, a Kafka, a Netty/Webflux stb. kérelmeket és függőségeket. Java SDK esetén a korrelációs funkció csak az Apache HttpClienten keresztül indított hívásokat támogatja. Az SDK nem támogatja az olyan üzenetkezelési technológiák közötti automatikus környezetterjesztést, mint a Kafka, a RabbitMQ és az Azure Service Bus.

Az egyéni telemetriai adatok gyűjtéséhez az alkalmazást Java 2.6 SDK-val kell rendszereznünk.

Szerepkörnevek

Előfordulhat, hogy testre szeretné szabni, hogy az összetevőnevek hogyan jelenjenek meg az Alkalmazástérképen. Ehhez manuálisan is beállíthatja cloud_RoleName az alábbi műveletek egyikét:

  • Az Alkalmazás Elemzések Java esetében állítsa be a felhőbeli szerepkör nevét az alábbiak szerint:

    {
  "role": {
    "name": "my cloud role name"
  }
}

    A felhőbeli szerepkör nevét a környezeti változóval APPLICATIONINSIGHTS_ROLE_NAMEis beállíthatja.

  • Az Application Elemzések Java SDK 2.5.0-s és újabb verzióival az alkalmazáshoz való hozzáadással <RoleName> adhatja meg cloud_RoleName Elemzések.xml fájlját:

    Screenshot that shows Application Insights overview and connection string. 

    <?xml version="1.0" encoding="utf-8"?>
<ApplicationInsights xmlns="http://schemas.microsoft.com/ApplicationInsights/2013/Settings" schemaVersion="2014-05-30">
   <ConnectionString>InstrumentationKey=00000000-0000-0000-0000-000000000000</ConnectionString>
   <RoleName>** Your role name **</RoleName>
   ...
</ApplicationInsights>

  • Ha a Spring Bootot az Application Elemzések Spring Boot Starter alkalmazással használja, állítsa be az alkalmazás egyéni nevét az application.properties fájlban:

    spring.application.name=<name-of-app>

A felhőbeli szerepkör nevét környezeti változó vagy rendszertulajdonság használatával is beállíthatja. Részletekért tekintse meg a felhőbeli szerepkör nevének konfigurálását ismertető cikket.

Következő lépések