Microsoft OpenTelemetry-exportőr az Azure Monitorhoz
Az Azure Monitor exportőre lehetővé teszi, hogy az OpenTelemetry SDK használatával exportálja az adatokat, és telemetriai adatokat küldjön az Azure Monitornak a Pythonban írt alkalmazásokhoz.
Forráskód | Csomag (PyPi) | API-referenciadokumentáció | Termékdokumentáció | Minták | Változatlan
Első lépések
A csomag telepítése
Telepítse az Azure Monitorhoz készült Microsoft OpenTelemetry-exportőrt a pip használatával:
pip install azure-monitor-opentelemetry-exporter --pre
Előfeltételek
A csomag használatához a következőket kell tennie:
- Azure-előfizetés – Ingyenes fiók létrehozása
- Azure Monitor – Az Application Insights használata
- OpenTelemetry SDK – OpenTelemetry SDK for Python
- Python 3.7 vagy újabb – A Python telepítése
Az ügyfél példányosítása
Az Azure Monitor-exportőrrel való interakció az elosztott nyomkövetés, AzureMonitorLogExporter
a naplózás és AzureMonitorMetricExporter
a AzureMonitorTraceExporter
metrikák osztályának egy példányával kezdődik. Az objektum példányosításához szüksége lesz egy connection_string .
Az alábbiakban csatolt mintákat talál az exportőr kapcsolati karakterlánc használatával történő felépítésének bemutatásához.
Naplózás (kísérleti)
MEGJEGYZÉS: A naplózási AzureMonitorLogExporter
jel jelenleg KÍSÉRLETI állapotban van. Lehetséges törési változások a jövőben következhetnek be.
from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter
exporter = AzureMonitorLogExporter(
connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
Mérőszámok
from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter
exporter = AzureMonitorMetricExporter(
connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
Nyomkövetés
from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
exporter = AzureMonitorTraceExporter(
connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
Az exportőrt közvetlenül a konstruktoron keresztül is létrehozhatja. Ebben az esetben a kapcsolati karakterlánc automatikusan ki lesz töltve a APPLICATIONINSIGHTS_CONNECTION_STRING
környezeti változóból.
from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter
exporter = AzureMonitorLogExporter()
from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter
exporter = AzureMonitorMetricExporter()
from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
exporter = AzureMonitorTraceExporter()
Fő fogalmak
Az Azure Monitor-exportőr néhány fő fogalma a következők:
OpenTelemetry: Az OpenTelemetry a telemetriai adatok (metrikák, naplók és nyomkövetések) elemzésre való gyűjtésére és exportálására használt kódtárak készlete a szoftver teljesítményének és viselkedésének megértéséhez.
Rendszerállapot: Az OpenTelemetry API bármely alkalmazás általi közvetlen meghívásának lehetőségét a rendszerállapot teszi lehetővé. Az OpenTelemetry megfigyelhetőségét egy másik kódtár esetében eszközkódtárnak nevezzük.
Napló: A napló a naplózás, a kivétel és az események rögzítésére utal.
LogRecord: Egy támogatott naplózási kódtárból kibocsátott naplórekordot jelöl.
Naplózó: Az a-t
LogRecord
olvashatóváLogData
alakítja, és az exportálandó SDK-on keresztül lesz leküldve.Naplózószolgáltató: Az adott rendszerállapot-kódtárhoz biztosít egy
Logger
elemet.LogRecordProcessor: A naplórekord-kibocsátó művelet összekapcsolásához használható felület.
LoggingHandler: Egy kezelőosztály, amely a naplózási rekordokat OpenTelemetry formátumban írja a standard Python-kódtárból
logging
.AzureMonitorLogExporter: Ez az a osztály, amely inicializálva van a naplózással kapcsolatos telemetriai adatok Azure Monitorba való küldéséhez.
Metrika:
Metric
a nyers mérések előre definiált aggregációval és attribútumkészletekkel történő rögzítésére vonatkozik egy adott időszakra vonatkozóan.Mérés: Egy adott időpontban rögzített adatpontot jelöl.
Eszköz: Az eszközök az s jelentésére
Measurement
szolgálnak.Mérő: A
Meter
felelős a létrehozásértInstruments
.Fogyasztásmérő-szolgáltató: A megadott rendszerállapot-kódtárhoz biztosít egy
Meter
értéket.Metrikaolvasó: Egy SDK-implementációs objektum, amely az OpenTelemetry Metrics SDK általános konfigurálható szempontjait biztosítja, például a gyűjteményt, a kiürítést és a leállítást.
AzureMonitorMetricExporter: Ez az a osztály, amely inicializálva van a metrikával kapcsolatos telemetriai adatok Azure Monitorba való küldéséhez.
Nyomkövetés: A nyomkövetés elosztott nyomkövetésre utal. Az elosztott nyomkövetés egy olyan eseménykészlet, amely egyetlen logikai művelet eredményeként aktiválódik, és egy alkalmazás különböző összetevőire van összevonva. A Nyomkövetés különösen a Spans irányított aciklikus gráfjaként (DAG) tekinthető, ahol a spanok közötti élek szülő-gyermek kapcsolatként vannak definiálva.
Span: Egyetlen műveletet jelöl egy adott műveleten
Trace
belül. Beágyazható egy nyomkövetési fa létrehozásához. Minden nyomkövetés tartalmaz egy gyökértartományt, amely általában a teljes műveletet írja le, és opcionálisan egy vagy több altartományt az alműveleteihez.Tracer: Felelős az s létrehozásához
Span
.Nyomkövetési szolgáltató: Az
Tracer
adott eszközkódtár számára használható.Span Processor: A span processzor lehetővé teszi az SDK
Span
kezdő és záró metódusának meghívását. További információért kövesse a hivatkozást.AzureMonitorTraceExporter: Ez az a osztály, amely inicializálva van a nyomkövetéssel kapcsolatos telemetriai adatok Azure Monitorba való küldéséhez.
Mintavételezés: A mintavételezés az OpenTelemetry által okozott zaj és többletterhelés szabályozására szolgáló mechanizmus, amely csökkenti a háttérrendszerbe gyűjtött és elküldött nyomkövetési minták számát.
ApplicationInsightsSampler: Az Application Insights SDK-k és az Application Insightsba adatokat küldő OpenTelemetry-alapú SDK-k konzisztens mintavételezéséhez használt Application Insights-specifikus mintavevő. Ezt a mintavevőt minden alkalommal
AzureMonitorTraceExporter
használni kell.
További információ ezekről az erőforrásokról: Mi az az Azure Monitor?.
Konfiguráció
Az összes konfigurációs lehetőség átadható az exportőrök konstruktorain keresztül.kwargs
Az alábbiakban a konfigurálható beállítások listája látható.
connection_string
: Az Application Insights-erőforráshoz használt kapcsolati karakterlánc.disable_offline_storage
: Logikai érték annak meghatározásához, hogy le szeretné-e tiltani a sikertelen telemetriai rekordok újrapróbálkozáshoz való tárolását. Alapértelmezés szerint a értékre van kapcsolvaFalse
.storage_directory
: Tárkönyvtár, amelyben újrapróbálkozó fájlokat tárolhat. Alapértelmezés szerint a értékre van kapcsolva<tempfile.gettempdir()>/Microsoft/AzureMonitor/opentelemetry-python-<your-instrumentation-key>
.credential
: Jogkivonat-hitelesítő adatok, például ManagedIdentityCredential vagy ClientSecretCredential, azure Active Directory-hitelesítéshez (AAD) használva. Alapértelmezés szerint Nincs. Példákért tekintse meg a példákat .
Példák
Naplózás (kísérleti)
MEGJEGYZÉS: A naplózási AzureMonitorLogExporter
jel jelenleg KÍSÉRLETI állapotban van. Lehetséges törési változások a jövőben következhetnek be.
A következő szakaszok számos kódrészletet biztosítanak, amelyek a leggyakoribb feladatok némelyikét tartalmazzák, többek között:
- Naplórekord exportálása
- Korrelált naplórekord exportálása
- Naplórekord exportálása egyéni tulajdonságokkal
- Kivételek naplórekordjának exportálása
Tekintse át az OpenTelemetry Logging SDK-t , és ismerje meg, hogyan gyűjthet naplókat az OpenTelemetry-összetevőkkel.
"Helló világ!" alkalmazás-napló exportálása
"""
An example to show an application using Opentelemetry logging sdk. Logging calls to the standard Python
logging library are tracked and telemetry is exported to application insights with the AzureMonitorLogExporter.
"""
import os
import logging
from opentelemetry.sdk._logs import (
LoggerProvider,
LoggingHandler,
set_logger_provider,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter
logger_provider = LoggerProvider()
set_logger_provider(logger_provider)
exporter = AzureMonitorLogExporter(
connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
handler = LoggingHandler()
# Attach LoggingHandler to root logger
logging.getLogger().addHandler(handler)
logging.getLogger().setLevel(logging.NOTSET)
logger = logging.getLogger(__name__)
logger.warning("Hello World!")
# Telemetry records are flushed automatically upon application exit
# If you would like to flush records manually yourself, you can call force_flush()
logger_provider.force_flush()
Korrelált napló exportálása
"""
An example showing how to include context correlation information in logging telemetry.
"""
import os
import logging
from opentelemetry import trace
from opentelemetry.sdk._logs import (
LoggerProvider,
LoggingHandler,
set_logger_provider,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.sdk.trace import TracerProvider
from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
logger_provider = LoggerProvider()
set_logger_provider(logger_provider)
exporter = AzureMonitorLogExporter(
connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
handler = LoggingHandler()
# Attach LoggingHandler to root logger
logging.getLogger().addHandler(handler)
logging.getLogger().setLevel(logging.NOTSET)
logger = logging.getLogger(__name__)
logger.info("INFO: Outside of span")
with tracer.start_as_current_span("foo"):
logger.warning("WARNING: Inside of span")
logger.error("ERROR: After span")
Egyéni tulajdonságok naplójának exportálása
"""
An example showing how to add custom properties to logging telemetry.
"""
import os
import logging
from opentelemetry.sdk._logs import (
LoggerProvider,
LoggingHandler,
set_logger_provider,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter
logger_provider = LoggerProvider()
set_logger_provider(logger_provider)
exporter = AzureMonitorLogExporter(
connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
handler = LoggingHandler()
# Attach LoggingHandler to root logger
logging.getLogger().addHandler(handler)
logging.getLogger().setLevel(logging.NOTSET)
logger = logging.getLogger(__name__)
# Custom properties
logger.debug("DEBUG: Debug with properties", extra={"debug": "true"})
Kivételnapló exportálása
"""
An example showing how to export exception telemetry using the AzureMonitorLogExporter.
"""
import os
import logging
from opentelemetry._logs import (
get_logger_provider,
set_logger_provider,
)
from opentelemetry.sdk._logs import (
LoggerProvider,
LoggingHandler,
)
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from azure.monitor.opentelemetry.exporter import AzureMonitorLogExporter
set_logger_provider(LoggerProvider())
exporter = AzureMonitorLogExporter(
connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
get_logger_provider().add_log_record_processor(BatchLogRecordProcessor(exporter))
# Attach LoggingHandler to namespaced logger
handler = LoggingHandler()
logger = logging.getLogger(__name__)
logger.addHandler(handler)
logger.setLevel(logging.NOTSET)
# The following code will generate two pieces of exception telemetry
# that are identical in nature
try:
val = 1 / 0
print(val)
except ZeroDivisionError:
logger.exception("Error: Division by zero")
try:
val = 1 / 0
print(val)
except ZeroDivisionError:
logger.error("Error: Division by zero", stack_info=True, exc_info=True)
Mérőszámok
A következő szakaszok számos kódrészletet biztosítanak, amelyek a leggyakoribb feladatok némelyikét tartalmazzák, többek között:
- Különböző metrikaeszközök használata
- Kimeneti metrikák testreszabása nézetekkel
- Eszközök rögzítése attribútumokkal
Tekintse át az OpenTelemetry Metrics SDK-t , és ismerje meg, hogyan gyűjthet metrikákat az OpenTelemetry-összetevőkkel.
Metrikaeszköz-használat
"""
An example to show an application using all instruments in the OpenTelemetry SDK. Metrics created
and recorded using the sdk are tracked and telemetry is exported to application insights with the
AzureMonitorMetricsExporter.
"""
import os
from typing import Iterable
from opentelemetry import metrics
from opentelemetry.metrics import CallbackOptions, Observation
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter
exporter = AzureMonitorMetricExporter(
connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
reader = PeriodicExportingMetricReader(exporter, export_interval_millis=5000)
metrics.set_meter_provider(MeterProvider(metric_readers=[reader]))
# Create a namespaced meter
meter = metrics.get_meter_provider().get_meter("sample")
# Callback functions for observable instruments
def observable_counter_func(options: CallbackOptions) -> Iterable[Observation]:
yield Observation(1, {})
def observable_up_down_counter_func(
options: CallbackOptions,
) -> Iterable[Observation]:
yield Observation(-10, {})
def observable_gauge_func(options: CallbackOptions) -> Iterable[Observation]:
yield Observation(9, {})
# Counter
counter = meter.create_counter("counter")
counter.add(1)
# Async Counter
observable_counter = meter.create_observable_counter(
"observable_counter", [observable_counter_func]
)
# UpDownCounter
up_down_counter = meter.create_up_down_counter("up_down_counter")
up_down_counter.add(1)
up_down_counter.add(-5)
# Async UpDownCounter
observable_up_down_counter = meter.create_observable_up_down_counter(
"observable_up_down_counter", [observable_up_down_counter_func]
)
# Histogram
histogram = meter.create_histogram("histogram")
histogram.record(99.9)
# Async Gauge
gauge = meter.create_observable_gauge("gauge", [observable_gauge_func])
# Upon application exit, one last collection is made and telemetry records are
# flushed automatically. # If you would like to flush records manually yourself,
# you can call force_flush()
meter_provider.force_flush()
Egyéni nézetek metrikái
"""
This example shows how to customize the metrics that are output by the SDK using Views. Metrics created
and recorded using the sdk are tracked and telemetry is exported to application insights with the
AzureMonitorMetricsExporter.
"""
import os
from opentelemetry import metrics
from opentelemetry.sdk.metrics import Counter, MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.metrics.view import View
from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter
exporter = AzureMonitorMetricExporter.from_connection_string(
os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
# Create a view matching the counter instrument `my.counter`
# and configure the new name `my.counter.total` for the result metrics stream
change_metric_name_view = View(
instrument_type=Counter,
instrument_name="my.counter",
name="my.counter.total",
)
reader = PeriodicExportingMetricReader(exporter, export_interval_millis=5000)
provider = MeterProvider(
metric_readers=[
reader,
],
views=[
change_metric_name_view,
],
)
metrics.set_meter_provider(provider)
meter = metrics.get_meter_provider().get_meter("view-name-change")
my_counter = meter.create_counter("my.counter")
my_counter.add(100)
A metrikák Views
SDK-jával kapcsolatos további példákat itt talál.
Metrikarekord-attribútumok
"""
An example to show an application using different attributes with instruments in the OpenTelemetry SDK.
Metrics created and recorded using the sdk are tracked and telemetry is exported to application insights
with the AzureMonitorMetricsExporter.
"""
import os
from opentelemetry import metrics
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from azure.monitor.opentelemetry.exporter import AzureMonitorMetricExporter
exporter = AzureMonitorMetricExporter.from_connection_string(
os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
reader = PeriodicExportingMetricReader(exporter, export_interval_millis=5000)
metrics.set_meter_provider(MeterProvider(metric_readers=[reader]))
attribute_set1 = {
"key1": "val1"
}
attribute_set2 = {
"key2": "val2"
}
large_attribute_set = {}
for i in range(20):
key = "key{}".format(i)
val = "val{}".format(i)
large_attribute_set[key] = val
meter = metrics.get_meter_provider().get_meter("sample")
# Counter
counter = meter.create_counter("attr1_counter")
counter.add(1, attribute_set1)
# Counter2
counter2 = meter.create_counter("attr2_counter")
counter2.add(10, attribute_set1)
counter2.add(30, attribute_set2)
# Counter3
counter3 = meter.create_counter("large_attr_counter")
counter3.add(100, attribute_set1)
counter3.add(200, large_attribute_set)
Nyomkövetés
A következő szakaszok számos kódrészletet biztosítanak, amelyek a leggyakoribb feladatok némelyikét tartalmazzák, többek között:
- Egyéni span exportálása
- Kódtár nyomon követésére szolgáló kialakítás használata
- A mintavételezés engedélyezése az elküldött telemetriai adatok mennyiségének korlátozásához
Tekintse át az OpenTelemetry Tracing SDK-t , és ismerje meg, hogyan gyűjthet naplókat az OpenTelemetry-összetevőkkel.
"Helló világ!" alkalmazás nyomkövetés exportálása
"""
An example to show an application using Opentelemetry tracing api and sdk. Custom dependencies are
tracked via spans and telemetry is exported to application insights with the AzureMonitorTraceExporter.
"""
import os
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
tracer_provider = TracerProvider()
trace.set_tracer_provider(tracer_provider)
tracer = trace.get_tracer(__name__)
# This is the exporter that sends data to Application Insights
exporter = AzureMonitorTraceExporter(
connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
span_processor = BatchSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
with tracer.start_as_current_span("hello"):
print("Hello, World!")
# Telemetry records are flushed automatically upon application exit
# If you would like to flush records manually yourself, you can call force_flush()
tracer_provider.force_flush()
Rendszerállapot kéréstárral
Az OpenTelemetry számos olyan kialakítást is támogat, amelyek lehetővé teszik a külső kódtárakkal való rendszerezést.
Az OpenTelemetryben elérhető kialakítások listáját a contrib dokumentációjában találja.
Ez a példa bemutatja, hogyan alakíthatja ki a kéréstárat .
- Telepítse a requests instrumentation csomagot a pip install opentelemetry-instrumentation-requests paranccsal.
"""
An example to show an application instrumented with the OpenTelemetry requests instrumentation.
Calls made with the requests library will be automatically tracked and telemetry is exported to
application insights with the AzureMonitorTraceExporter.
See more info on the requests instrumentation here:
https://github.com/open-telemetry/opentelemetry-python-contrib/tree/main/instrumentation/opentelemetry-instrumentation-requests
"""
import os
import requests
from opentelemetry import trace
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from azure.monitor.opentelemetry.exporter import AzureMonitorTraceExporter
# This line causes your calls made with the requests library to be tracked.
RequestsInstrumentor().instrument()
trace.set_tracer_provider(TracerProvider())
tracer = trace.get_tracer(__name__)
exporter = AzureMonitorTraceExporter(
connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
span_processor = BatchSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
# This request will be traced
response = requests.get(url="https://azure.microsoft.com/")
Mintavételezés engedélyezése
Engedélyezheti a mintavételezést a kapott telemetriai rekordok mennyiségének korlátozásához. A helyes mintavételezés az Application Insightsban való engedélyezéséhez használja az ApplicationInsightsSampler
alábbit.
"""
An example to show an application using the ApplicationInsightsSampler to enable sampling for your telemetry.
Specify a sampling rate for the sampler to limit the amount of telemetry records you receive. Custom dependencies
are tracked via spans and telemetry is exported to application insights with the AzureMonitorTraceExporter.
"""
import os
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from azure.monitor.opentelemetry.exporter import (
ApplicationInsightsSampler,
AzureMonitorTraceExporter,
)
# Sampler expects a sample rate of between 0 and 1 inclusive
# A rate of 0.75 means approximately 75% of your telemetry will be sent
sampler = ApplicationInsightsSampler(0.75)
trace.set_tracer_provider(TracerProvider(sampler=sampler))
tracer = trace.get_tracer(__name__)
exporter = AzureMonitorTraceExporter(
connection_string=os.environ["APPLICATIONINSIGHTS_CONNECTION_STRING"]
)
span_processor = BatchSpanProcessor(exporter)
trace.get_tracer_provider().add_span_processor(span_processor)
for i in range(100):
# Approximately 25% of these spans should be sampled out
with tracer.start_as_current_span("hello"):
print("Hello, World!")
Kiürítési/leállítási viselkedés
Az OpenTelemetry SDK-val és az Azure Monitor-exportőrökkel beállított összes alkalmazás esetében a rendszer automatikusan kiüríti a telemetriát az alkalmazásból való kilépéskor. Vegye figyelembe, hogy ez nem vonatkozik arra az esetre, ha az alkalmazás hirtelen véget ér, vagy váratlan kivétel miatt összeomlik.
Hibaelhárítás
Az exportőr kivételeket emel ki az Azure Core-ban.
Következő lépések
További mintakód
További példákat a gyakori forgatókönyveket bemutató mintakönyvtárban talál.
További dokumentáció
Az Azure Monitor szolgáltatással kapcsolatos részletesebb dokumentációért tekintse meg az Azure Monitor dokumentációját a docs.microsoft.com.
Az OpenTelemetry részletes áttekintését az áttekintési oldalon találja.
A hivatalos OpenTelemetry Python-dokumentációért és az egyéb telemetriai forgatókönyvek engedélyezéséhez látogasson el a hivatalos OpenTelemetry webhelyre.
Az Azure Monitor OpenTelemetry disztribúcióról, amely hasznos, előre összeállított összetevők (ezek egyike az aktuális csomag) csomagja, amely lehetővé teszi a telemetriai forgatókönyveket az Azure Monitorral, látogasson el a README webhelyre.
Közreműködés
A projektben szívesen fogadjuk a hozzájárulásokat és a javaslatokat. A legtöbb hozzájáruláshoz el kell fogadnia egy Közreműködői licencszerződést (CLA-t), amelyben kijelenti, hogy jogosult arra, hogy ránk ruházza hozzájárulása felhasználási jogát, és ezt ténylegesen meg is teszi. További részletekért lásd: https://cla.microsoft.com.
A lekéréses kérelmek elküldésekor egy CLA-robot automatikusan meghatározza, hogy kell-e biztosítania CLA-t, és megfelelően kitölti a lekéréses kérelmet (például címke, megjegyzés). Egyszerűen csak kövesse a robot által megadott utasításokat. Ezt csak egyszer kell elvégeznie az összes olyan tárházban, amely a CLA-t használja.
A projekt a Microsoft nyílt forráskódú projekteket szabályozó etikai kódexe, a Microsoft Open Source Code of Conduct hatálya alá esik. További információkért lásd a viselkedési szabályzattal kapcsolatos gyakori kérdéseket , vagy vegye fel a kapcsolatot opencode@microsoft.com az esetleges további kérdésekkel vagy megjegyzésekkel.
Azure SDK for Python