github/azure-sdk-for-cpp
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Update samples credentials and add notes to crypto client (#5587)

Browse Source 
* Update samples credentials and add notes to crypto client

* put back missing urls
This commit is contained in:
George Arama 2024-05-01 08:19:57 -07:00 committed by GitHub
parent bd08d226e1
commit a168e0ef0f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
31 changed files with 110 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
sdk/keyvault/azure-security-keyvault-certificates/README.md
View File

@ -62,7 +62,9 @@ Key Vault Certificate client for C++ currently supports any `TokenCredential` fo
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:CertificateSample1Client
CertificateClient certificateClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
CertificateClient certificateClient(keyVaultUrl, credential);
```
### Start creating a Certificate

12
sdk/keyvault/azure-security-keyvault-certificates/samples/certificate-basic-operations/certificate_basic_operations.cpp
View File

@ -7,9 +7,6 @@
*
* @remark The following environment variables must be set before running the sample.
* - AZURE_KEYVAULT_URL: To the Key Vault account URL.
* - AZURE_TENANT_ID: Tenant ID for the Azure account.
* - AZURE_CLIENT_ID: The Client ID to authenticate the request.
* - AZURE_CLIENT_SECRET: The client secret.
*
*/
@ -25,14 +22,11 @@ using namespace std::chrono_literals;
int main()
{
auto tenantId = std::getenv("AZURE_TENANT_ID");
auto clientId = std::getenv("AZURE_CLIENT_ID");
auto clientSecret = std::getenv("AZURE_CLIENT_SECRET");
auto credential
= std::make_shared<Azure::Identity::ClientSecretCredential>(tenantId, clientId, clientSecret);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
std::chrono::milliseconds defaultWait(10s);
// create client
CertificateClient certificateClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
CertificateClient certificateClient(keyVaultUrl, credential);
try
{

12
sdk/keyvault/azure-security-keyvault-certificates/samples/certificate-get-certificates/certificate_get_certificates.cpp
View File

@ -10,9 +10,6 @@
*
* @remark The following environment variables must be set before running the sample.
* - AZURE_KEYVAULT_URL: To the Key Vault account URL.
* - AZURE_TENANT_ID: Tenant ID for the Azure account.
* - AZURE_CLIENT_ID: The Client ID to authenticate the request.
* - AZURE_CLIENT_SECRET: The client secret.
*
*/
@ -32,14 +29,11 @@ KeyVaultCertificateWithPolicy CreateCertificate(
int main()
{
auto tenantId = std::getenv("AZURE_TENANT_ID");
auto clientId = std::getenv("AZURE_CLIENT_ID");
auto clientSecret = std::getenv("AZURE_CLIENT_SECRET");
auto credential
= std::make_shared<Azure::Identity::ClientSecretCredential>(tenantId, clientId, clientSecret);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
std::chrono::milliseconds defaultWait(10s);
// create client
CertificateClient certificateClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
CertificateClient certificateClient(keyVaultUrl, credential);
try
{

12
sdk/keyvault/azure-security-keyvault-certificates/samples/certificate-import-certificate/certificate_import_certificate.cpp
View File

@ -7,9 +7,6 @@
*
* @remark The following environment variables must be set before running the sample.
* - AZURE_KEYVAULT_URL: To the Key Vault account URL.
* - AZURE_TENANT_ID: Tenant ID for the Azure account.
* - AZURE_CLIENT_ID: The Client ID to authenticate the request.
* - AZURE_CLIENT_SECRET: The client secret.
*
*/
@ -28,14 +25,11 @@ std::string GetPkcsCertificate();
int main()
{
auto tenantId = std::getenv("AZURE_TENANT_ID");
auto clientId = std::getenv("AZURE_CLIENT_ID");
auto clientSecret = std::getenv("AZURE_CLIENT_SECRET");
auto credential
= std::make_shared<Azure::Identity::ClientSecretCredential>(tenantId, clientId, clientSecret);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
std::chrono::milliseconds defaultWait(10s);
// create client
CertificateClient certificateClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
CertificateClient certificateClient(keyVaultUrl, credential);
try
{

6
sdk/keyvault/azure-security-keyvault-certificates/samples/certificate_basic_operations.md
View File

@ -17,13 +17,15 @@ To create a new `CertificateClient` to create, get, update, or delete certificat
Key Vault Certificate client for C++ currently supports any `TokenCredential` for authenticating.
```cpp Snippet:CertificateSample1CreateCredential
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
```
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:CertificateSample1Client
CertificateClient certificateClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
CertificateClient certificateClient(keyVaultUrl, credential);
```
## Creating a Certificate

4
sdk/keyvault/azure-security-keyvault-certificates/samples/certificate_get_certificates.md
View File

@ -24,7 +24,9 @@ Key Vault Certificate client for C++ currently supports any `TokenCredential` fo
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:CertificateSample2Client
CertificateClient certificateClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
CertificateClient certificateClient(keyVaultUrl, credential);
```
## Creating a Certificate

6
sdk/keyvault/azure-security-keyvault-certificates/samples/certificate_import_certificate.md
View File

@ -10,13 +10,15 @@ To create a new `CertificateClient` to create, get, update, or delete certificat
Key Vault Certificate client for C++ currently supports any `TokenCredential` for authenticating.
```cpp Snippet:CertificateSample3CreateCredential
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
```
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:CertificateSample3Client
CertificateClient certificateClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
CertificateClient certificateClient(keyVaultUrl, credential);
```
## Importing a PEM certificate

10
sdk/keyvault/azure-security-keyvault-keys/README.md
View File

@ -154,9 +154,11 @@ az keyvault security-domain download --hsm-name <your-key-vault-name> --sd-wrapp
Once you've replaced **your-vault-url** with the above returned URI, you can create the [KeyClient][key_client_class]:
```cpp
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
// Create a new key client using the default credential from Azure Identity.
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
KeyClient client("AZURE_KEYVAULT_URL", credential);
KeyClient keyClient(keyVaultUrl, credential);;
// Create a new key using the key client.
client.CreateKey("key-name", KeyVaultKeyType::Rsa);
@ -189,6 +191,12 @@ A `KeyClient` providing synchronous operations exists in the SDK. Once you've in
A `CryptographyClient` providing synchronous operations exists in the SDK. Once you've initialized a `CryptographyClient`, you can use it to perform cryptographic operations with keys stored in Azure Key Vault.
#### Note
Microsoft recommends you not use CBC without first ensuring the integrity of the cipher text using an HMAC, for example. See https://docs.microsoft.com/dotnet/standard/security/vulnerabilities-cbc-mode for more information.
Optional initialization vector (IV). If you pass your own IV, make sure you use a cryptographically random, non-repeating IV. If null, a cryptographically random IV will be choosing using {RandomNumberGenerator | whatever cryptorng your language provides}.
### Thread safety
We guarantee that all client instance methods are thread-safe and independent of each other ([guideline](https://azure.github.io/azure-sdk/cpp_introduction.html#thread-safety)). This ensures that the recommendation of reusing client instances is always safe, even across threads.

9
sdk/keyvault/azure-security-keyvault-keys/samples/sample1-hello-world/sample1_hello_world.cpp
View File

@ -7,9 +7,6 @@
*
* @remark The following environment variables must be set before running the sample.
* - AZURE_KEYVAULT_URL: To the Key Vault account URL.
* - AZURE_TENANT_ID: Tenant ID for the Azure account.
* - AZURE_CLIENT_ID: The Client ID to authenticate the request.
* - AZURE_CLIENT_SECRET: The client secret.
*
*/
@ -26,12 +23,8 @@ using namespace Azure::Security::KeyVault::Keys;
int main()
{
auto const tenantId = std::getenv("AZURE_TENANT_ID");
auto const clientId = std::getenv("AZURE_CLIENT_ID");
auto const clientSecret = std::getenv("AZURE_CLIENT_SECRET");
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential
= std::make_shared<Azure::Identity::ClientSecretCredential>(tenantId, clientId, clientSecret);
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
KeyClient keyClient(keyVaultUrl, credential);

6
sdk/keyvault/azure-security-keyvault-keys/samples/sample1_hello_world.md
View File

@ -10,13 +10,15 @@ To create a new `KeyClient` to create, get, update, or delete keys, you need the
Key Vault Keys client for C++ currently supports any `TokenCredential` for authenticating.
```cpp Snippet:KeysSample1CreateCredential
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
```
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:KeysSample1KeyClient
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
KeyClient keyClient(keyVaultUrl, credential);
```
## Creating a key

12
sdk/keyvault/azure-security-keyvault-keys/samples/sample2-backup-and-restore/sample2_backup_and_restore.cpp
View File

@ -7,9 +7,6 @@
*
* @remark The following environment variables must be set before running the sample.
* - AZURE_KEYVAULT_URL: To the Key Vault account URL.
* - AZURE_TENANT_ID: Tenant ID for the Azure account.
* - AZURE_CLIENT_ID: The Client ID to authenticate the request.
* - AZURE_CLIENT_SECRET: The client secret.
*
*/
@ -30,13 +27,10 @@ static void AssertKeysEqual(KeyProperties const& expected, KeyProperties const&
int main()
{
auto tenantId = std::getenv("AZURE_TENANT_ID");
auto clientId = std::getenv("AZURE_CLIENT_ID");
auto clientSecret = std::getenv("AZURE_CLIENT_SECRET");
auto credential
= std::make_shared<Azure::Identity::ClientSecretCredential>(tenantId, clientId, clientSecret);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
KeyClient keyClient(keyVaultUrl, credential);
std::string rsaKeyName("CloudRsaKey" + Azure::Core::Uuid::CreateUuid().ToString());
try

6
sdk/keyvault/azure-security-keyvault-keys/samples/sample2_backup_and_restore.md
View File

@ -12,13 +12,15 @@ Key Vault Keys client for C++ currently supports any `TokenCredential` for authe
In the sample below, you can create a credential by setting the Tenant ID, Client ID and client secret as environment variables.
```cpp Snippet:KeysSample1CreateCredential
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
```
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:KeysSample1KeyClient
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
KeyClient keyClient(keyVaultUrl, credential);
```
## Creating a key

12
sdk/keyvault/azure-security-keyvault-keys/samples/sample3-get-keys/sample3_get_keys.cpp
View File

@ -8,9 +8,6 @@
*
* @remark The following environment variables must be set before running the sample.
* - AZURE_KEYVAULT_URL: To the Key Vault account URL.
* - AZURE_TENANT_ID: Tenant ID for the Azure account.
* - AZURE_CLIENT_ID: The Client ID to authenticate the request.
* - AZURE_CLIENT_SECRET: The client secret.
*
*/
@ -28,13 +25,10 @@ using namespace Azure::Security::KeyVault::Keys;
int main()
{
auto tenantId = std::getenv("AZURE_TENANT_ID");
auto clientId = std::getenv("AZURE_CLIENT_ID");
auto clientSecret = std::getenv("AZURE_CLIENT_SECRET");
auto credential
= std::make_shared<Azure::Identity::ClientSecretCredential>(tenantId, clientId, clientSecret);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
KeyClient keyClient(keyVaultUrl, credential);
try
{

6
sdk/keyvault/azure-security-keyvault-keys/samples/sample3_get_keys.md
View File

@ -12,13 +12,15 @@ Key Vault Keys client for C++ currently supports any `TokenCredential` for authe
In the sample below, you can create a credential by setting the Tenant ID, Client ID and client secret as environment variables.
```cpp Snippet:KeysSample1CreateCredential
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
```
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:KeysSample1KeyClient
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
KeyClient keyClient(keyVaultUrl, credential);
```
## Creating a key

12
sdk/keyvault/azure-security-keyvault-keys/samples/sample4-encrypt-decrypt/sample4_encrypt_decrypt.cpp
View File

@ -7,9 +7,6 @@
*
* @remark The following environment variables must be set before running the sample.
* - AZURE_KEYVAULT_URL: To the Key Vault account URL.
* - AZURE_TENANT_ID: Tenant ID for the Azure account.
* - AZURE_CLIENT_ID: The Client ID to authenticate the request.
* - AZURE_CLIENT_SECRET: The client secret.
*
*/
@ -27,13 +24,10 @@ using namespace std::chrono_literals;
int main()
{
auto tenantId = std::getenv("AZURE_TENANT_ID");
auto clientId = std::getenv("AZURE_CLIENT_ID");
auto clientSecret = std::getenv("AZURE_CLIENT_SECRET");
auto credential
= std::make_shared<Azure::Identity::ClientSecretCredential>(tenantId, clientId, clientSecret);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
KeyClient keyClient(keyVaultUrl, credential);
// Let's create a RSA key which will be used to encrypt and decrypt
auto rsaKeyName = "CloudRsaKey-" + Azure::Core::Uuid::CreateUuid().ToString();

9
sdk/keyvault/azure-security-keyvault-keys/samples/sample4_encrypt_decrypt.md
View File

@ -12,13 +12,15 @@ Key Vault Keys client for C++ currently supports any `TokenCredential` for authe
In the sample below, you can create a credential by setting the Tenant ID, Client ID and client secret as environment variables.
```cpp Snippet:KeysSample1CreateCredential
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
```
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:KeysSample1KeyClient
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
KeyClient keyClient(keyVaultUrl, credential);
```
## Creating a key
@ -71,5 +73,8 @@ std::cout << " - Decrypted data using the algorithm " << decryptResult.Algorithm
```
## Source
To see the full example source, see:
- [sample4_encrypt_decrypt.cpp](https://github.com/Azure/azure-sdk-for-cpp/blob/main/sdk/keyvault/azure-security-keyvault-keys/samples/sample4-encrypt-decrypt/sample4_encrypt_decrypt.cpp)
[defaultazurecredential]: https://github.com/Azure/azure-sdk-for-cpp/blob/main/sdk/identity/azure-identity/README.md

13
sdk/keyvault/azure-security-keyvault-keys/samples/sample5-sign-verify/sample5_sign_verify.cpp
View File

@ -7,9 +7,6 @@
*
* @remark The following environment variables must be set before running the sample.
* - AZURE_KEYVAULT_URL: To the Key Vault account URL.
* - AZURE_TENANT_ID: Tenant ID for the Azure account.
* - AZURE_CLIENT_ID: The Client ID to authenticate the request.
* - AZURE_CLIENT_SECRET: The client secret.
*
*/
@ -27,14 +24,10 @@ using namespace std::chrono_literals;
int main()
{
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
auto tenantId = std::getenv("AZURE_TENANT_ID");
auto clientId = std::getenv("AZURE_CLIENT_ID");
auto clientSecret = std::getenv("AZURE_CLIENT_SECRET");
auto credential
= std::make_shared<Azure::Identity::ClientSecretCredential>(tenantId, clientId, clientSecret);
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
KeyClient keyClient(keyVaultUrl, credential);
auto rsaKeyName = "CloudRsaKey-" + Azure::Core::Uuid::CreateUuid().ToString();
auto keyOptions = CreateRsaKeyOptions(rsaKeyName, false);

9
sdk/keyvault/azure-security-keyvault-keys/samples/sample5_sign_verify.md
View File

@ -12,13 +12,15 @@ Key Vault Keys client for C++ currently supports any `TokenCredential` for authe
In the sample below, you can create a credential by setting the Tenant ID, Client ID and client secret as environment variables.
```cpp Snippet:KeysSample1CreateCredential
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
```
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:KeysSample1KeyClient
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
KeyClient keyClient(keyVaultUrl, credential);
```
## Creating keys
@ -137,5 +139,8 @@ std::cout << " - Verified the signature using the algorithm "
```
## Source
To see the full example source, see:
- [sample5_sign_verify.cpp](https://github.com/Azure/azure-sdk-for-cpp/blob/main/sdk/keyvault/azure-security-keyvault-keys/samples/sample5-sign-verify/sample5_sign_verify.cpp)
[defaultazurecredential]: https://github.com/Azure/azure-sdk-for-cpp/blob/main/sdk/identity/azure-identity/README.md

12
sdk/keyvault/azure-security-keyvault-keys/samples/sample6-wrap-unwrap/sample6_wrap_unwrap.cpp
View File

@ -7,9 +7,6 @@
*
* @remark The following environment variables must be set before running the sample.
* - AZURE_KEYVAULT_URL: To the Key Vault account URL.
* - AZURE_TENANT_ID: Tenant ID for the Azure account.
* - AZURE_CLIENT_ID: The Client ID to authenticate the request.
* - AZURE_CLIENT_SECRET: The client secret.
*
*/
@ -27,13 +24,10 @@ using namespace std::chrono_literals;
int main()
{
auto tenantId = std::getenv("AZURE_TENANT_ID");
auto clientId = std::getenv("AZURE_CLIENT_ID");
auto clientSecret = std::getenv("AZURE_CLIENT_SECRET");
auto credential
= std::make_shared<Azure::Identity::ClientSecretCredential>(tenantId, clientId, clientSecret);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
KeyClient keyClient(keyVaultUrl, credential);
auto rsaKeyName = "CloudRsaKey-" + Azure::Core::Uuid::CreateUuid().ToString();
auto keyOptions = CreateRsaKeyOptions(rsaKeyName, false);

6
sdk/keyvault/azure-security-keyvault-keys/samples/sample6_wrap_unwrap.md
View File

@ -12,13 +12,15 @@ Key Vault Keys client for C++ currently supports any `TokenCredential` for authe
In the sample below, you can create a credential by setting the Tenant ID, Client ID and client secret as environment variables.
```cpp Snippet:KeysSample6CreateCredential
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
```
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:KeysSample6KeyClient
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
KeyClient keyClient(keyVaultUrl, credential);
```
## Creating a key

12
sdk/keyvault/azure-security-keyvault-keys/samples/sample7-key-rotation/sample7_key_rotation.cpp
View File

@ -7,9 +7,6 @@
*
* @remark The following environment variables must be set before running the sample.
* - AZURE_KEYVAULT_URL: To the Key Vault account URL.
* - AZURE_TENANT_ID: Tenant ID for the Azure account.
* - AZURE_CLIENT_ID: The Client ID to authenticate the request.
* - AZURE_CLIENT_SECRET: The client secret.
*
*/
@ -27,13 +24,10 @@ using namespace std::chrono_literals;
int main()
{
auto tenantId = std::getenv("AZURE_TENANT_ID");
auto clientId = std::getenv("AZURE_CLIENT_ID");
auto clientSecret = std::getenv("AZURE_CLIENT_SECRET");
auto credential
= std::make_shared<Azure::Identity::ClientSecretCredential>(tenantId, clientId, clientSecret);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
KeyClient keyClient(keyVaultUrl, credential);
auto keyName = "RotateKey-" + Azure::Core::Uuid::CreateUuid().ToString();
auto createKeyResponse = keyClient.CreateEcKey(CreateEcKeyOptions(keyName));

4
sdk/keyvault/azure-security-keyvault-keys/samples/sample7_key_rotation.md
View File

@ -18,7 +18,9 @@ auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:KeysSample7KeyClient
KeyClient keyClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
KeyClient keyClient(keyVaultUrl, credential);
```
## Creating a key

4
sdk/keyvault/azure-security-keyvault-secrets/README.md
View File

@ -52,10 +52,10 @@ For detailed samples please review the samples provided.
First step is to create a SecretClient.
```cpp
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
// create client
SecretClient secretClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
SecretClient secretClient(keyVaultUrl, credential);
```
### Create a secret

3
sdk/keyvault/azure-security-keyvault-secrets/samples/sample1-basic-operations/sample1_basic_operations.cpp
View File

@ -21,11 +21,12 @@ using namespace std::chrono_literals;
int main()
{
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
// @begin_snippet: SecretSample1CreateCredential
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
// create client
SecretClient secretClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
SecretClient secretClient(keyVaultUrl, credential);
// @end_snippet
try

5
sdk/keyvault/azure-security-keyvault-secrets/samples/sample1_basic_operations.md
View File

@ -18,7 +18,10 @@ auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:SecretSample1SecretClient
SecretClient secretClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
// create client
SecretClient secretClient(keyVaultUrl, credential);
```
## Creating a Secret

3
sdk/keyvault/azure-security-keyvault-secrets/samples/sample2-backup-restore/sample2_backup_restore.cpp
View File

@ -24,10 +24,11 @@ void AssertSecretsEqual(KeyVaultSecret const& expected, KeyVaultSecret const& ac
int main()
{
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
// create client
SecretClient secretClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
SecretClient secretClient(keyVaultUrl, credential);
std::string secretName("MySampleSecret2");
std::string secretValue("my secret value");

5
sdk/keyvault/azure-security-keyvault-secrets/samples/sample2_backup_restore.md
View File

@ -18,7 +18,10 @@ auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:SecretSample2SecretClient
SecretClient secretClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
// create client
SecretClient secretClient(keyVaultUrl, credential);
```
## Creating a Secret

4
sdk/keyvault/azure-security-keyvault-secrets/samples/sample3-delete-recover/sample3_delete_recover.cpp
View File

@ -23,10 +23,10 @@ void AssertSecretsEqual(KeyVaultSecret const& expected, KeyVaultSecret const& ac
int main()
{
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
// create client
SecretClient secretClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
SecretClient secretClient(keyVaultUrl, credential);
std::string secretName("MySampleSecret");
std::string secretValue("my secret value");

5
sdk/keyvault/azure-security-keyvault-secrets/samples/sample3_delete_recover.md
View File

@ -17,7 +17,10 @@ auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp Snippet:SecretSample3SecretClient
SecretClient secretClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
// create client
SecretClient secretClient(keyVaultUrl, credential);
```
## Creating a Secret

4
sdk/keyvault/azure-security-keyvault-secrets/samples/sample4-get-secrets-deleted/sample4_get_secrets_deleted.cpp
View File

@ -21,10 +21,10 @@ using namespace std::chrono_literals;
int main()
{
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
// create client
SecretClient secretClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
SecretClient secretClient(keyVaultUrl, credential);
std::string secretName("Secret1");
std::string secretName2("Secret2");

5
sdk/keyvault/azure-security-keyvault-secrets/samples/sample4_get_secrets_deleted.md
View File

@ -17,7 +17,10 @@ auto credential = std::make_shared<Azure::Identity::DefaultAzureCredential>();
Then, in the sample below, you can set `keyVaultUrl` based on an environment variable, configuration setting, or any way that works for your application.
```cpp
SecretClient secretClient(std::getenv("AZURE_KEYVAULT_URL"), credential);
auto const keyVaultUrl = std::getenv("AZURE_KEYVAULT_URL");
...
// create client
SecretClient secretClient(keyVaultUrl, credential);
```
## Creating a couple of Secrets