Service Bus hozzáférés-vezérlés közös hozzáférési aláírásokkalService Bus access control with Shared Access Signatures

A közös hozzáférésű aláírások (SAS) a Service Bus üzenetkezelés elsődleges biztonsági mechanizmusa.Shared Access Signatures (SAS) are the primary security mechanism for Service Bus messaging. Ez a cikk az SAS-t, a működésük módját és a platform-független módon való használatát ismerteti.This article discusses SAS, how they work, and how to use them in a platform-agnostic way.

Az SAS az engedélyezési szabályokon alapuló Service Bushoz fér hozzá.SAS guards access to Service Bus based on authorization rules. Ezek a névterek vagy üzenetküldési entitások (Relay, üzenetsor vagy témakör) szerint vannak konfigurálva.Those are configured either on a namespace, or a messaging entity (relay, queue, or topic). Az engedélyezési szabályok névvel rendelkeznek, bizonyos jogokkal vannak társítva, és egy pár titkosítási kulcsot is végrehajt.An authorization rule has a name, is associated with specific rights, and carries a pair of cryptographic keys. A szabály nevét és kulcsát a Service Bus SDK-n vagy a saját kódjában használhatja SAS-token létrehozásához.You use the rule's name and key via the Service Bus SDK or in your own code to generate a SAS token. Az ügyfél ezután átadhatja a jogkivonatot a Service Busnak, hogy igazolja a kért művelet engedélyezését.A client can then pass the token to Service Bus to prove authorization for the requested operation.

Megjegyzés

Azure Service Bus támogatja a Service Bus névterek és az entitások hozzáférésének engedélyezését Azure Active Directory (Azure AD) használatával.Azure Service Bus supports authorizing access to a Service Bus namespace and its entities using Azure Active Directory (Azure AD). Az Azure AD által visszaadott OAuth 2,0 tokent használó felhasználók vagy alkalmazások engedélyezése kiváló biztonságot és egyszerű használatot biztosít a közös hozzáférésű aláírások (SAS) számára.Authorizing users or applications using OAuth 2.0 token returned by Azure AD provides superior security and ease of use over shared access signatures (SAS). Az Azure AD-ben nincs szükség a jogkivonatok tárolására a kódban, és kockázatos biztonsági réseket.With Azure AD, there is no need to store the tokens in your code and risk potential security vulnerabilities.

A Microsoft azt javasolja, hogy ha lehetséges, az Azure AD-t használja a Azure Service Bus alkalmazásaihoz.Microsoft recommends using Azure AD with your Azure Service Bus applications when possible. További információkért tekintse át a következő cikkeket:For more information, see the following articles:

SAS áttekintéseOverview of SAS

A közös hozzáférésű aláírások egy egyszerű tokeneket használó jogcím-alapú engedélyezési mechanizmus.Shared Access Signatures are a claims-based authorization mechanism using simple tokens. A SAS használatával a kulcsok soha nem lesznek átadva a huzalon.Using SAS, keys are never passed on the wire. A kulcsok a szolgáltatás által később ellenőrizhető információk titkosítására szolgálnak.Keys are used to cryptographically sign information that can later be verified by the service. Az SAS a Felhasználónév és a jelszó sémához hasonló módon használható, ahol az ügyfél azonnal rendelkezik egy engedélyezési szabály nevével és egy hozzá tartozó kulccsal.SAS can be used similar to a username and password scheme where the client is in immediate possession of an authorization rule name and a matching key. Az SAS az összevont biztonsági modellhez hasonlóan is használható, ahol az ügyfél időkorlátos és aláírt hozzáférési jogkivonatot kap a biztonsági jogkivonat szolgáltatástól anélkül, hogy az aláírási kulcs birtokában lenne.SAS can also be used similar to a federated security model, where the client receives a time-limited and signed access token from a security token service without ever coming into possession of the signing key.

A Service Bus SAS-hitelesítése olyan megosztott hozzáférés-engedélyezési szabályokkal van konfigurálva, amelyek hozzáférési jogosultságokkal rendelkeznek, valamint az elsődleges és másodlagos titkosítási kulcsok párja.SAS authentication in Service Bus is configured with named Shared Access Authorization Rules having associated access rights, and a pair of primary and secondary cryptographic keys. A kulcsok 256 bites értékek Base64-ábrázolásban.The keys are 256-bit values in Base64 representation. Megadhatja a szabályokat a névtér szintjén , Service Bus-továbbítókat, várólistákatés témaköröket.You can configure rules at the namespace level, on Service Bus relays, queues, and topics.

A közös hozzáférésű aláírási jogkivonat tartalmazza a kiválasztott engedélyezési szabály nevét, az elérni kívánt erőforrás URI-ját, a lejárati pillanatot, valamint a HMAC-sha256 titkosítási aláírást, amely a kiválasztott engedélyezési szabály elsődleges vagy másodlagos titkosítási kulcsa alapján lett kiszámítva.The Shared Access Signature token contains the name of the chosen authorization rule, the URI of the resource that shall be accessed, an expiry instant, and an HMAC-SHA256 cryptographic signature computed over these fields using either the primary or the secondary cryptographic key of the chosen authorization rule.

Megosztott hozzáférés engedélyezési házirendjeiShared Access Authorization Policies

Minden Service Bus névtérnek és minden Service Bus entitásnak van egy közös hozzáférési engedélyezési szabályzata, amely szabályokból áll.Each Service Bus namespace and each Service Bus entity has a Shared Access Authorization policy made up of rules. A névtér szintjén lévő szabályzat a névtéren belüli összes entitásra vonatkozik, függetlenül az egyes házirend-konfigurációtól.The policy at the namespace level applies to all entities inside the namespace, irrespective of their individual policy configuration.

Minden egyes engedélyezési házirend-szabályhoz három információt kell eldöntenie: név, hatókörés jogosultságok.For each authorization policy rule, you decide on three pieces of information: name, scope, and rights. A név csak az; a hatókörön belüli egyedi név.The name is just that; a unique name within that scope. A hatókör elég egyszerű: Ez a kérdéses erőforrás URI-ja.The scope is easy enough: it's the URI of the resource in question. Service Bus névtér esetében a hatókör a teljes tartománynév (FQDN), például: https://<yournamespace>.servicebus.windows.net/ .For a Service Bus namespace, the scope is the fully qualified domain name (FQDN), such as https://<yournamespace>.servicebus.windows.net/.

A házirend-szabály által biztosított jogok a következőket foglalhatják magukban:The rights conferred by the policy rule can be a combination of:

  • Send (küldés) – meghatalmazza a jogot arra, hogy üzeneteket küldjön az entitásnak'Send' - Confers the right to send messages to the entity
  • "Listen" – meghatalmazza a figyelésre (továbbításra) vagy fogadásra (Üzenetsor, előfizetések) és az összes kapcsolódó üzenet kezelésére vonatkozó jogot.'Listen' - Confers the right to listen (relay) or receive (queue, subscriptions) and all related message handling
  • "Manage" – a jogosult a névtér topológiájának kezelésére, beleértve az entitások létrehozását és törlését.'Manage' - Confers the right to manage the topology of the namespace, including creating and deleting entities

A "kezelés" jogosultság magában foglalja a "Send" és a "Receive" jogosultságot.The 'Manage' right includes the 'Send' and 'Receive' rights.

A névtér vagy az entitások házirendje legfeljebb 12 közös hozzáférési engedélyezési szabályt tud tárolni, amelyek három szabálykészlet számára biztosítanak helyet, amelyek mindegyike rendelkezik az alapszintű jogokkal, valamint a Küldés és a figyelés kombinációjával.A namespace or entity policy can hold up to 12 Shared Access Authorization rules, providing room for three sets of rules, each covering the basic rights and the combination of Send and Listen. Ez a korlát azt hangsúlyozza, hogy a SAS-szabályzat tárolója nem a felhasználó-vagy szolgáltatásfiók-tároló.This limit underlines that the SAS policy store is not intended to be a user or service account store. Ha az alkalmazásnak felhasználói vagy szolgáltatásbeli identitások alapján kell hozzáférést biztosítania Service Bushoz, akkor olyan biztonsági jogkivonat-szolgáltatást kell létrehoznia, amely az SAS-tokeneket a hitelesítés és a hozzáférés-ellenőrzések után bocsátja ki.If your application needs to grant access to Service Bus based on user or service identities, it should implement a security token service that issues SAS tokens after an authentication and access check.

Az engedélyezési szabályokhoz egy elsődleges kulcs és egy másodlagos kulcsvan rendelve.An authorization rule is assigned a Primary Key and a Secondary Key. Ezek kriptográfiai szempontból erős kulcsok.These are cryptographically strong keys. Ne veszítse el őket, vagy ne szivárogjon rájuk – mindig a Azure Portallesznek elérhetők.Don't lose them or leak them - they'll always be available in the Azure portal. A generált kulcsok bármelyikét használhatja, és bármikor újragenerálhatja őket.You can use either of the generated keys, and you can regenerate them at any time. Ha újra létrehoz vagy módosít egy kulcsot a házirendben, az adott kulcson alapuló, korábban kiadott jogkivonatok azonnal érvénytelenné válnak.If you regenerate or change a key in the policy, all previously issued tokens based on that key become instantly invalid. Az ilyen jogkivonatok alapján létrehozott folyamatban lévő kapcsolatok azonban továbbra is működni fognak, amíg a jogkivonat le nem jár.However, ongoing connections created based on such tokens will continue to work until the token expires.

Service Bus névtér létrehozásakor a rendszer automatikusan létrehoz egy RootManageSharedAccessKey nevű házirend-szabályt a névtérhez.When you create a Service Bus namespace, a policy rule named RootManageSharedAccessKey is automatically created for the namespace. Ez a szabályzat a teljes névtérre vonatkozó engedélyeket kezeli.This policy has Manage permissions for the entire namespace. Javasoljuk, hogy ezt a szabályt rendszergazdai főfiókként kezelje, és ne használja az alkalmazásban.It's recommended that you treat this rule like an administrative root account and don't use it in your application. A portálon, a PowerShell vagy az Azure CLI használatával további szabályzatokat hozhat létre a névtér configure (Konfigurálás ) lapján.You can create additional policy rules in the Configure tab for the namespace in the portal, via PowerShell or Azure CLI.

A közös hozzáférésű aláírások hitelesítésének konfigurációjaConfiguration for Shared Access Signature authentication

A SharedAccessAuthorizationRule szabályt Service Bus névterek, várólisták vagy témakörök esetében is konfigurálhatja.You can configure the SharedAccessAuthorizationRule rule on Service Bus namespaces, queues, or topics. A SharedAccessAuthorizationRule Service Bus-előfizetésre való konfigurálása jelenleg nem támogatott, de a névtéren vagy témakörben konfigurált szabályokkal biztonságossá teheti az előfizetésekhez való hozzáférést.Configuring a SharedAccessAuthorizationRule on a Service Bus subscription is currently not supported, but you can use rules configured on a namespace or topic to secure access to subscriptions. Az eljárást bemutató munkaminta esetében tekintse meg a közös hozzáférésű aláírás (SAS) hitelesítés használata Service Bus előfizetések mintáját.For a working sample that illustrates this procedure, see the Using Shared Access Signature (SAS) authentication with Service Bus Subscriptions sample.

SAS

Ebben az ábrán a manageRuleNS, a SendRuleNSés a listenRuleNS engedélyezési szabályok mind a "Q1", mind a "T1" témakörre érvényesek, míg a listenRuleQ és a sendRuleQ csak a Q1-es és a sendRuleT-re vonatkozik, és a sendRuleT csak a (In this figure, the manageRuleNS, sendRuleNS, and listenRuleNS authorization rules apply to both queue Q1 and topic T1, while listenRuleQ and sendRuleQ apply only to queue Q1 and sendRuleT applies only to topic T1.

Közös hozzáférésű aláírási jogkivonat létrehozásaGenerate a Shared Access Signature token

Minden olyan ügyfél létrehozhat egy SAS-jogkivonatot, amely egy engedélyezési szabály nevének és az egyik aláíró kulcsnak a nevéhez fér hozzá.Any client that has access to name of an authorization rule name and one of its signing keys can generate a SAS token. A jogkivonat a következő formátumú sztringek létrehozásával jön létre:The token is generated by crafting a string in the following format:

SharedAccessSignature sig=<signature-string>&se=<expiry>&skn=<keyName>&sr=<URL-encoded-resourceURI>
  • se -A jogkivonat lejárati ideje azonnali.se - Token expiry instant. Az egész szám, amely a 00:00:00 UTC (z) 1970. január 1-jén (UNIX-kor), a jogkivonat lejárati idejének lejárta óta.Integer reflecting seconds since the epoch 00:00:00 UTC on 1 January 1970 (UNIX epoch) when the token expires.
  • skn – Az engedélyezési szabály neve.skn - Name of the authorization rule.
  • sr -Az elérni kívánt erőforrás URI-ja.sr - URI of the resource being accessed.
  • sig Aláírás.sig - Signature.

Az az signature-string SHA-256 kivonat, amely az erőforrás URI-ja alapjánscope lett kiszámítva (az előző szakaszban leírtak szerint), valamint a jogkivonat lejárati időpontjának karakterláncos ábrázolása, az LF elválasztva.The signature-string is the SHA-256 hash computed over the resource URI (scope as described in the previous section) and the string representation of the token expiry instant, separated by LF.

A kivonatoló számítás a következő pszeudo-kódhoz hasonlóan néz ki, és egy 256 bites/32 bájtos kivonatoló értéket ad vissza.The hash computation looks similar to the following pseudo code and returns a 256-bit/32-byte hash value.

SHA-256('https://<yournamespace>.servicebus.windows.net/'+'\n'+ 1438205742)

A jogkivonat a nem kivonatos értékeket tartalmazza, így a címzett újra kiszámíthatja a kivonatot ugyanazzal a paraméterekkel, és ellenőrizheti, hogy a kiállító rendelkezik-e érvényes aláíró kulccsal.The token contains the non-hashed values so that the recipient can recompute the hash with the same parameters, verifying that the issuer is in possession of a valid signing key.

Az erőforrás URI-ja annak a Service Bus-erőforrásnak a teljes URI azonosítója, amelyhez hozzáférést igényelnek.The resource URI is the full URI of the Service Bus resource to which access is claimed. Például: http://<namespace>.servicebus.windows.net/<entityPath> vagy sb://<namespace>.servicebus.windows.net/<entityPath> ;, azaz, http://contoso.servicebus.windows.net/contosoTopics/T1/Subscriptions/S3 .For example, http://<namespace>.servicebus.windows.net/<entityPath> or sb://<namespace>.servicebus.windows.net/<entityPath>; that is, http://contoso.servicebus.windows.net/contosoTopics/T1/Subscriptions/S3.

Az URI-nak százalékos kódolássalkell rendelkeznie.The URI must be percent-encoded.

Az aláíráshoz használt megosztott hozzáférés-engedélyezési szabályt az URI által megadott entitáson vagy annak egyik hierarchikus szülője szerint kell konfigurálni.The shared access authorization rule used for signing must be configured on the entity specified by this URI, or by one of its hierarchical parents. Például vagy az http://contoso.servicebus.windows.net/contosoTopics/T1 http://contoso.servicebus.windows.net előző példában.For example, http://contoso.servicebus.windows.net/contosoTopics/T1 or http://contoso.servicebus.windows.net in the previous example.

Az SAS-token érvényes minden olyan erőforráshoz, amelyet a <resourceURI> -ben használt signature-string .A SAS token is valid for all resources prefixed with the <resourceURI> used in the signature-string.

Megjegyzés

Az SAS-token különböző programozási nyelveken való generálására példákat az sas-jogkivonat létrehozásacímű témakörben talál.For examples of generating a SAS token using different programming languages, see Generate SAS token.

Kulcsok újragenerálásaRegenerating keys

Javasoljuk, hogy rendszeresen újragenerálja a SharedAccessAuthorizationRule objektumban használt kulcsokat.It is recommended that you periodically regenerate the keys used in the SharedAccessAuthorizationRule object. Az elsődleges és a másodlagos kulcs tárolóhelyei úgy vannak, hogy a kulcsok fokozatos elforgatása is megtörténjen.The primary and secondary key slots exist so that you can rotate keys gradually. Ha az alkalmazás általában az elsődleges kulcsot használja, akkor az elsődleges kulcsot a másodlagos kulcs tárolóhelyére másolhatja, és csak ezután generálhatja újra az elsődleges kulcsot.If your application generally uses the primary key, you can copy the primary key into the secondary key slot, and only then regenerate the primary key. Az új elsődleges kulcs értéke ezután konfigurálható az ügyfélalkalmazások között, amelyek továbbra is hozzáférnek a régi elsődleges kulcs használatával a másodlagos tárolóhelyen.The new primary key value can then be configured into the client applications, which have continued access using the old primary key in the secondary slot. Az összes ügyfél frissítése után újragenerálhatja a másodlagos kulcsot, hogy végül kivonja a régi elsődleges kulcsot.Once all clients are updated, you can regenerate the secondary key to finally retire the old primary key.

Ha ismeri vagy gyanítja, hogy a kulcs biztonsága sérül, és vissza kell vonnia a kulcsokat, újra létrehozhatja a SharedAccessAuthorizationRule PrimaryKey és értesítésiközpont , és új kulcsokkal helyettesítheti azokat.If you know or suspect that a key is compromised and you have to revoke the keys, you can regenerate both the PrimaryKey and the SecondaryKey of a SharedAccessAuthorizationRule, replacing them with new keys. Ez az eljárás érvényteleníti a régi kulcsokkal aláírt összes jogkivonatot.This procedure invalidates all tokens signed with the old keys.

Közös hozzáférésű aláírások hitelesítése Service BusShared Access Signature authentication with Service Bus

Az alábbi forgatókönyvek az engedélyezési szabályok konfigurálását, az SAS-jogkivonatok létrehozását és az ügyfél-engedélyezést tartalmazzák.The scenarios described as follows include configuration of authorization rules, generation of SAS tokens, and client authorization.

A konfigurációt bemutató és SAS-hitelesítést használó Service Bus alkalmazás teljes munkamintája: a közös hozzáférésű aláírások hitelesítése Service Bushasználatával.For a full working sample of a Service Bus application that illustrates the configuration and uses SAS authorization, see Shared Access Signature authentication with Service Bus. Az Service Bus-előfizetések biztonságossá tételéhez a névtereken vagy témakörökben konfigurált SAS-engedélyezési szabályok használatát bemutató kapcsolódó minta itt érhető el: közös hozzáférésű aláírás (SAS) hitelesítés használata Service Bus előfizetésekkel.A related sample that illustrates the use of SAS authorization rules configured on namespaces or topics to secure Service Bus subscriptions is available here: Using Shared Access Signature (SAS) authentication with Service Bus Subscriptions.

Megosztott hozzáférés engedélyezési szabályainak elérése egy entitásonAccess Shared Access Authorization rules on an entity

A Service Bus .NET-keretrendszer könyvtáraival a megfelelő QueueDescription vagy TopicDescriptiona engedélyezési szabályok -gyűjteményen keresztül érheti el a Microsoft. ServiceBus. Messaging. SharedAccessAuthorizationRule objektumot, amely egy Service Bus-várólistán vagy-témakörön van konfigurálva.With Service Bus .NET Framework libraries, you can access a Microsoft.ServiceBus.Messaging.SharedAccessAuthorizationRule object configured on a Service Bus queue or topic through the AuthorizationRules collection in the corresponding QueueDescription or TopicDescription.

A következő kód bemutatja, hogyan adhat hozzá egy üzenetsor engedélyezési szabályait.The following code shows how to add authorization rules for a queue.

// Create an instance of NamespaceManager for the operation
NamespaceManager nsm = NamespaceManager.CreateFromConnectionString(
    <connectionString> );
QueueDescription qd = new QueueDescription( <qPath> );

// Create a rule with send rights with keyName as "contosoQSendKey"
// and add it to the queue description.
qd.Authorization.Add(new SharedAccessAuthorizationRule("contosoSendKey",
    SharedAccessAuthorizationRule.GenerateRandomKey(),
    new[] { AccessRights.Send }));

// Create a rule with listen rights with keyName as "contosoQListenKey"
// and add it to the queue description.
qd.Authorization.Add(new SharedAccessAuthorizationRule("contosoQListenKey",
    SharedAccessAuthorizationRule.GenerateRandomKey(),
    new[] { AccessRights.Listen }));

// Create a rule with manage rights with keyName as "contosoQManageKey"
// and add it to the queue description.
// A rule with manage rights must also have send and receive rights.
qd.Authorization.Add(new SharedAccessAuthorizationRule("contosoQManageKey",
    SharedAccessAuthorizationRule.GenerateRandomKey(),
    new[] {AccessRights.Manage, AccessRights.Listen, AccessRights.Send }));

// Create the queue.
nsm.CreateQueue(qd);

Közös hozzáférésű aláírás engedélyezésének használataUse Shared Access Signature authorization

Az Azure .NET SDK-t és a Service Bus .NET-kódtárakat használó alkalmazások a SharedAccessSignatureTokenProvider osztályon keresztül HASZNÁLHATJÁK az SAS-engedélyezést.Applications using the Azure .NET SDK with the Service Bus .NET libraries can use SAS authorization through the SharedAccessSignatureTokenProvider class. A következő kód a jogkivonat-szolgáltató használatát mutatja be üzenetek küldésére egy Service Bus üzenetsor számára.The following code illustrates the use of the token provider to send messages to a Service Bus queue. Az itt látható használat alternatívájaként egy korábban kiadott tokent is átadhat a jogkivonat-szolgáltató gyári metódusának.Alternative to the usage shown here, you can also pass a previously issued token to the token provider factory method.

Uri runtimeUri = ServiceBusEnvironment.CreateServiceUri("sb",
    <yourServiceNamespace>, string.Empty);
MessagingFactory mf = MessagingFactory.Create(runtimeUri,
    TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, key));
QueueClient sendClient = mf.CreateQueueClient(qPath);

//Sending hello message to queue.
BrokeredMessage helloMessage = new BrokeredMessage("Hello, Service Bus!");
helloMessage.MessageId = "SAS-Sample-Message";
sendClient.Send(helloMessage);

A jogkivonat-szolgáltatót közvetlenül is használhatja a jogkivonatok kiadására a más ügyfelek számára.You can also use the token provider directly for issuing tokens to pass to other clients.

A kapcsolati karakterláncok tartalmazhatnak egy szabály nevét (SharedAccessKeyName) és a szabály kulcsát (SharedAccessKey) vagy egy korábban kiállított tokent (SharedAccessSignature).Connection strings can include a rule name (SharedAccessKeyName) and rule key (SharedAccessKey) or a previously issued token (SharedAccessSignature). Ha ezek szerepelnek a kapcsolati sztringet fogadó vagy előállító metódusnak átadott kapcsolati sztringben, a rendszer automatikusan létrehozza és feltölti az SAS-jogkivonat-szolgáltatót.When those are present in the connection string passed to any constructor or factory method accepting a connection string, the SAS token provider is automatically created and populated.

Vegye figyelembe, hogy az SAS-hitelesítés Service Bus-továbbítókkal való használatához a Service Bus névtérben konfigurált SAS-kulcsokat is használhat.Note that to use SAS authorization with Service Bus relays, you can use SAS keys configured on the Service Bus namespace. Ha explicit módon létrehoz egy továbbítót a névtérben (NamespaceManager egy RelayDescription), akkor csak az adott továbbítóra vonatkozóan állíthatja be a sas-szabályokat.If you explicitly create a relay on the namespace (NamespaceManager with a RelayDescription) object, you can set the SAS rules just for that relay. Az SAS-engedélyezés Service Bus-előfizetésekkel való használatához Service Bus névtérben vagy témakörben konfigurált SAS-kulcsokat használhat.To use SAS authorization with Service Bus subscriptions, you can use SAS keys configured on a Service Bus namespace or on a topic.

A közös hozzáférésű aláírás használata (HTTP-szinten)Use the Shared Access Signature (at HTTP level)

Most, hogy már tudja, hogyan hozhat létre közös hozzáférési aláírásokat a Service Busban lévő összes entitáshoz, készen áll egy HTTP-bejegyzés végrehajtására:Now that you know how to create Shared Access Signatures for any entities in Service Bus, you are ready to perform an HTTP POST:

POST https://<yournamespace>.servicebus.windows.net/<yourentity>/messages
Content-Type: application/json
Authorization: SharedAccessSignature sr=https%3A%2F%2F<yournamespace>.servicebus.windows.net%2F<yourentity>&sig=<yoursignature from code above>&se=1438205742&skn=KeyName
ContentType: application/atom+xml;type=entry;charset=utf-8

Ne feledje, ez mindenre működik.Remember, this works for everything. Létrehozhat SAS-t egy üzenetsor, témakör vagy előfizetés számára.You can create SAS for a queue, topic, or subscription.

Ha SAS-tokent ad a küldőnek vagy az ügyfélnek, nem rendelkezik közvetlenül a kulccsal, és nem tudja visszafordítani a kivonatot a beszerzéséhez.If you give a sender or client a SAS token, they don't have the key directly, and they cannot reverse the hash to obtain it. Így Ön szabályozhatja, hogy mire férhet hozzá, és hogy mennyi ideig tart.As such, you have control over what they can access, and for how long. Fontos megjegyezni, hogy ha módosítja a házirend elsődleges kulcsát, akkor az abból létrehozott megosztott hozzáférési aláírások érvénytelenítve lesznek.An important thing to remember is that if you change the primary key in the policy, any Shared Access Signatures created from it are invalidated.

A közös hozzáférésű aláírás használata (AMQP szinten)Use the Shared Access Signature (at AMQP level)

Az előző szakaszban megtudhatta, hogyan használhatja az SAS-tokent egy HTTP POST-kérelemmel az adatoknak a Service Bus való küldéséhez.In the previous section, you saw how to use the SAS token with an HTTP POST request for sending data to the Service Bus. Amint tudja, hozzáférhet a Service Bushoz a Advanced Message Queueing Protocol (AMQP) használatával, amely a teljesítmény szempontjából előnyben részesített protokoll, és számos forgatókönyv esetén használható.As you know, you can access Service Bus using the Advanced Message Queuing Protocol (AMQP) that is the preferred protocol to use for performance reasons, in many scenarios. Az SAS-token AMQP-mel való használata a 2013-es AMQP Claim-Based Security 1,0-es verziójában van leírva, de az Azure által jelenleg támogatott.The SAS token usage with AMQP is described in the document AMQP Claim-Based Security Version 1.0 that is in working draft since 2013 but it's supported by Azure today.

Mielőtt megkezdené az adatküldést a Service Busba, a közzétevőnek az SAS-jogkivonatot egy $CBS nevű, jól DEFINIÁLt AMQP-csomópontra kell küldenie egy AMQP (a szolgáltatás által az összes sas-token beszerzéséhez és ellenőrzéséhez használt "speciális" üzenetsorként jelenik meg).Before starting to send data to Service Bus, the publisher must send the SAS token inside an AMQP message to a well-defined AMQP node named $cbs (you can see it as a "special" queue used by the service to acquire and validate all the SAS tokens). A közzétevőnek meg kell adnia a ReplyTo MEZŐT a AMQP üzenetben; Ez az a csomópont, amelyben a szolgáltatás a jogkivonatok érvényesítésének eredményeképpen válaszol a közzétevőnek (egyszerű kérelem/válasz minta a közzétevő és a szolgáltatás között).The publisher must specify the ReplyTo field inside the AMQP message; this is the node in which the service replies to the publisher with the result of the token validation (a simple request/reply pattern between publisher and service). Ez a válasz-csomópont "menet közben" jön létre, amely a "távoli csomópont dinamikus létrehozására" szól a AMQP 1,0 specifikációban leírtak szerint.This reply node is created "on the fly," speaking about "dynamic creation of remote node" as described by the AMQP 1.0 specification. Miután ellenőrizte, hogy az SAS-jogkivonat érvényes-e, a közzétevő mehet előre, és megkezdheti az adatküldést a szolgáltatásnak.After checking that the SAS token is valid, the publisher can go forward and start to send data to the service.

A következő lépések bemutatják, hogyan küldheti el az SAS-tokent a AMQP protokollal a AMQP.net Lite Library használatával.The following steps show how to send the SAS token with AMQP protocol using the AMQP.NET Lite library. Ez akkor hasznos, ha nem használhatja a (z) C platformon fejleszthető hivatalos Service Bus SDK-t (például WinRT, .NET kompakt keretrendszer, .NET Micro Framework és mono) # .This is useful if you can't use the official Service Bus SDK (for example on WinRT, .NET Compact Framework, .NET Micro Framework and Mono) developing in C#. Természetesen ez a könyvtár hasznos lehet annak megértésében, hogyan működik a jogcímek biztonsága a AMQP szinten, ahogy látta, hogyan működik a HTTP-szinten (HTTP POST-kéréssel és az "engedélyezés" fejlécben küldött SAS-tokenrel).Of course, this library is useful to help understand how claims-based security works at the AMQP level, as you saw how it works at the HTTP level (with an HTTP POST request and the SAS token sent inside the "Authorization" header). Ha nincs szüksége ilyen mélyre az AMQP-ről, a hivatalos Service Bus SDK-val .NET-keretrendszerbeli alkalmazásokkal is elvégezheti a használatát.If you don't need such deep knowledge about AMQP, you can use the official Service Bus SDK with .NET Framework applications, which will do it for you.

C#C#

/// <summary>
/// Send claim-based security (CBS) token
/// </summary>
/// <param name="shareAccessSignature">Shared access signature (token) to send</param>
private bool PutCbsToken(Connection connection, string sasToken)
{
    bool result = true;
    Session session = new Session(connection);

    string cbsClientAddress = "cbs-client-reply-to";
    var cbsSender = new SenderLink(session, "cbs-sender", "$cbs");
    var cbsReceiver = new ReceiverLink(session, cbsClientAddress, "$cbs");

    // construct the put-token message
    var request = new Message(sasToken);
    request.Properties = new Properties();
    request.Properties.MessageId = Guid.NewGuid().ToString();
    request.Properties.ReplyTo = cbsClientAddress;
    request.ApplicationProperties = new ApplicationProperties();
    request.ApplicationProperties["operation"] = "put-token";
    request.ApplicationProperties["type"] = "servicebus.windows.net:sastoken";
    request.ApplicationProperties["name"] = Fx.Format("amqp://{0}/{1}", sbNamespace, entity);
    cbsSender.Send(request);

    // receive the response
    var response = cbsReceiver.Receive();
    if (response == null || response.Properties == null || response.ApplicationProperties == null)
    {
        result = false;
    }
    else
    {
        int statusCode = (int)response.ApplicationProperties["status-code"];
        if (statusCode != (int)HttpStatusCode.Accepted && statusCode != (int)HttpStatusCode.OK)
        {
            result = false;
        }
    }

    // the sender/receiver may be kept open for refreshing tokens
    cbsSender.Close();
    cbsReceiver.Close();
    session.Close();

    return result;
}

A PutCbsToken() metódus fogadja a kapcsolat (AMQP-kapcsolati osztály példányát, amelyet a AMQP .net Lite Libraryadott meg), amely a szolgáltatás TCP-kapcsolatát és a sasToken paramétert jelöli, amely a küldendő sas-jogkivonat.The PutCbsToken() method receives the connection (AMQP connection class instance as provided by the AMQP .NET Lite library) that represents the TCP connection to the service and the sasToken parameter that is the SAS token to send.

Megjegyzés

Fontos, hogy a kapcsolat SASL hitelesítési mechanizmussal legyen létrehozva névtelen (és nem az alapértelmezett egyszerű felhasználónévvel és jelszóval, amelyet akkor használ, ha nem kell ELKÜLDENI az SAS-jogkivonatot).It's important that the connection is created with SASL authentication mechanism set to ANONYMOUS (and not the default PLAIN with username and password used when you don't need to send the SAS token).

Ezután a közzétevő két AMQP-hivatkozást hoz létre az SAS-token küldéséhez és a válasz fogadásához (jogkivonat-érvényesítési eredmény) a szolgáltatástól.Next, the publisher creates two AMQP links for sending the SAS token and receiving the reply (the token validation result) from the service.

A AMQP-üzenet tulajdonságok készletét és további információkat tartalmaz, mint egy egyszerű üzenet.The AMQP message contains a set of properties, and more information than a simple message. Az SAS-token az üzenet törzse (a konstruktorának használatával).The SAS token is the body of the message (using its constructor). A "ReplyTo" tulajdonság értéke a csomópont neve, amely a fogadó hivatkozáson keresztül fogadja az érvényesítési eredményt (ha szeretné, módosíthatja a nevét, és a szolgáltatás dinamikusan létrehozza azt).The "ReplyTo" property is set to the node name for receiving the validation result on the receiver link (you can change its name if you want, and it will be created dynamically by the service). A szolgáltatás az utolsó három alkalmazást/egyéni tulajdonságot használja arra, hogy jelezze, milyen műveletet kell végrehajtania.The last three application/custom properties are used by the service to indicate what kind of operation it has to execute. A CBS-draft specifikációjának megfelelően a művelet neve ("Put-token"), a jogkivonat típusa (ebben az esetben a servicebus.windows.net:sastoken ) és annak a célközönségnek a neve , amelyre a jogkivonat vonatkozik (a teljes entitás).As described by the CBS draft specification, they must be the operation name ("put-token"), the type of token (in this case, a servicebus.windows.net:sastoken), and the "name" of the audience to which the token applies (the entire entity).

Miután elküldte az SAS-tokent a küldő hivatkozáson, a közzétevőnek el kell olvasnia a választ a fogadó hivatkozáson.After sending the SAS token on the sender link, the publisher must read the reply on the receiver link. A válasz egy egyszerű AMQP üzenet, amely egy "Status-Code" nevű Application tulajdonságot tartalmaz, amely ugyanazokat az értékeket tartalmazza, mint a http-állapotkód.The reply is a simple AMQP message with an application property named "status-code" that can contain the same values as an HTTP status code.

Service Bus műveletekhez szükséges jogosultságokRights required for Service Bus operations

A következő táblázat a Service Bus erőforrásokon végzett különféle műveletekhez szükséges hozzáférési jogosultságokat mutatja be.The following table shows the access rights required for various operations on Service Bus resources.

MűveletOperation Jogcím szükségesClaim Required Jogcím hatóköreClaim Scope
NévtérNamespace
Engedélyezési szabály konfigurálása névtérbenConfigure authorization rule on a namespace KezelésManage Bármely névtér címeAny namespace address
Szolgáltatás beállításjegyzékeService Registry
Privát szabályzatok enumerálásaEnumerate Private Policies KezelésManage Bármely névtér címeAny namespace address
Névtér figyelésének megkezdéseBegin listening on a namespace FigyelésListen Bármely névtér címeAny namespace address
Üzenetek küldése egy figyelőnek egy névtérbenSend messages to a listener at a namespace KüldésSend Bármely névtér címeAny namespace address
ÜzenetsorQueue
Üzenetsor létrehozásaCreate a queue KezelésManage Bármely névtér címeAny namespace address
Üzenetsor törléseDelete a queue KezelésManage Bármely érvényes várólista-címeAny valid queue address
Várólisták enumerálásaEnumerate queues KezelésManage /$Resources/Queues/$Resources/Queues
A várólista leírásának beolvasásaGet the queue description KezelésManage Bármely érvényes várólista-címeAny valid queue address
A várólista engedélyezési szabályának konfigurálásaConfigure authorization rule for a queue KezelésManage Bármely érvényes várólista-címeAny valid queue address
Küldés a várólistábaSend into to the queue KüldésSend Bármely érvényes várólista-címeAny valid queue address
Üzenetek fogadása egy várólistábólReceive messages from a queue FigyelésListen Bármely érvényes várólista-címeAny valid queue address
Üzenetek megszakítása vagy befejezése az üzenet betekintés-zárolási módban való fogadása utánAbandon or complete messages after receiving the message in peek-lock mode FigyelésListen Bármely érvényes várólista-címeAny valid queue address
Üzenet késleltetése későbbi lekéréshezDefer a message for later retrieval FigyelésListen Bármely érvényes várólista-címeAny valid queue address
Üzenet kézbesítetlen levelekDeadletter a message FigyelésListen Bármely érvényes várólista-címeAny valid queue address
Az üzenetsor-munkamenethez társított állapot beolvasásaGet the state associated with a message queue session FigyelésListen Bármely érvényes várólista-címeAny valid queue address
Az üzenetsor-munkamenethez társított állapot beállításaSet the state associated with a message queue session FigyelésListen Bármely érvényes várólista-címeAny valid queue address
A későbbi kézbesítésre vonatkozó üzenet beütemezett időpontja például: ScheduleMessageAsync ()Schedule a message for later delivery; for example, ScheduleMessageAsync() FigyelésListen Bármely érvényes várólista-címeAny valid queue address
TémakörTopic
Üzenettémakör létrehozásaCreate a topic KezelésManage Bármely névtér címeAny namespace address
Témakör törléseDelete a topic KezelésManage Bármely érvényes témakör címeAny valid topic address
Témakörök enumerálásaEnumerate topics KezelésManage /$Resources/topics/$Resources/Topics
A témakör leírásának beolvasásaGet the topic description KezelésManage Bármely érvényes témakör címeAny valid topic address
Egy témakör engedélyezési szabályának konfigurálásaConfigure authorization rule for a topic KezelésManage Bármely érvényes témakör címeAny valid topic address
Küldés a következő témakörbeSend to the topic KüldésSend Bármely érvényes témakör címeAny valid topic address
ElőfizetésSubscription
Előfizetés létrehozásaCreate a subscription KezelésManage Bármely névtér címeAny namespace address
Előfizetés törléseDelete subscription KezelésManage .. /myTopic/Subscriptions/mySubscription../myTopic/Subscriptions/mySubscription
Előfizetések számbavételeEnumerate subscriptions KezelésManage .. /myTopic/Subscriptions../myTopic/Subscriptions
Előfizetés lekérése – LeírásGet subscription description KezelésManage .. /myTopic/Subscriptions/mySubscription../myTopic/Subscriptions/mySubscription
Üzenetek megszakítása vagy befejezése az üzenet betekintés-zárolási módban való fogadása utánAbandon or complete messages after receiving the message in peek-lock mode FigyelésListen .. /myTopic/Subscriptions/mySubscription../myTopic/Subscriptions/mySubscription
Üzenet késleltetése későbbi lekéréshezDefer a message for later retrieval FigyelésListen .. /myTopic/Subscriptions/mySubscription../myTopic/Subscriptions/mySubscription
Üzenet kézbesítetlen levelekDeadletter a message FigyelésListen .. /myTopic/Subscriptions/mySubscription../myTopic/Subscriptions/mySubscription
A témakör-munkamenethez társított állapot beolvasásaGet the state associated with a topic session FigyelésListen .. /myTopic/Subscriptions/mySubscription../myTopic/Subscriptions/mySubscription
Témakör-munkamenethez társított állapot beállításaSet the state associated with a topic session FigyelésListen .. /myTopic/Subscriptions/mySubscription../myTopic/Subscriptions/mySubscription
SzabályokRules
Szabály létrehozásaCreate a rule KezelésManage .. /myTopic/Subscriptions/mySubscription../myTopic/Subscriptions/mySubscription
Szabály törléseDelete a rule KezelésManage .. /myTopic/Subscriptions/mySubscription../myTopic/Subscriptions/mySubscription
Szabályok számbavételeEnumerate rules Kezelés vagy figyelésManage or Listen .. /myTopic/Subscriptions/mySubscription/Rules../myTopic/Subscriptions/mySubscription/Rules

Következő lépésekNext steps

A Service Bus üzenetkezelésről az alábbi témakörökben találhat további információkat.To learn more about Service Bus messaging, see the following topics.