SDK do Azure Key Vault Certificates para Rust

Biblioteca cliente para Certificados do Azure Key Vault — armazenamento e gerenciamento seguros de certificados.

Instalação

cargo add azure_security_keyvault_certificates azure_identity

Variáveis de Ambiente

AZURE_KEYVAULT_URL=https://<vault-name>.vault.azure.net/

Autenticação

use azure_identity::DeveloperToolsCredential;
use azure_security_keyvault_certificates::CertificateClient;

let credential = DeveloperToolsCredential::new(None)?;
let client = CertificateClient::new(
    "https://<vault-name>.vault.azure.net/",
    credential.clone(),
    None,
)?;

Operações Principais

Obter Certificado

use azure_core::base64;

let certificate = client
    .get_certificate("certificate-name", None)
    .await?
    .into_model()?;

println!(
    "Thumbprint: {:?}",
    certificate.x509_thumbprint.map(base64::encode_url_safe)
);

Criar Certificado

use azure_security_keyvault_certificates::models::{
    CreateCertificateParameters, CertificatePolicy,
    IssuerParameters, X509CertificateProperties,
};

let policy = CertificatePolicy {
    issuer_parameters: Some(IssuerParameters {
        name: Some("Self".into()),
        ..Default::default()
    }),
    x509_certificate_properties: Some(X509CertificateProperties {
        subject: Some("CN=example.com".into()),
        ..Default::default()
    }),
    ..Default::default()
};

let params = CreateCertificateParameters {
    certificate_policy: Some(policy),
    ..Default::default()
};

let operation = client
    .create_certificate("cert-name", params.try_into()?, None)
    .await?;

Importar Certificado

use azure_security_keyvault_certificates::models::ImportCertificateParameters;

let params = ImportCertificateParameters {
    base64_encoded_certificate: Some(base64_cert_data),
    password: Some("optional-password".into()),
    ..Default::default()
};

let certificate = client
    .import_certificate("cert-name", params.try_into()?, None)
    .await?
    .into_model()?;

Excluir Certificado

client.delete_certificate("certificate-name", None).await?;

Listar Certificados

use azure_security_keyvault_certificates::ResourceExt;
use futures::TryStreamExt;

let mut pager = client.list_certificate_properties(None)?.into_stream();
while let Some(cert) = pager.try_next().await? {
    let name = cert.resource_id()?.name;
    println!("Certificate: {}", name);
}

Obter Política de Certificado

let policy = client
    .get_certificate_policy("certificate-name", None)
    .await?
    .into_model()?;

Atualizar Política de Certificado

use azure_security_keyvault_certificates::models::UpdateCertificatePolicyParameters;

let params = UpdateCertificatePolicyParameters {
    // Update policy properties
    ..Default::default()
};

client
    .update_certificate_policy("cert-name", params.try_into()?, None)
    .await?;

Ciclo de Vida do Certificado

1. Criar — gera um novo certificado com política
2. Importar — importa um certificado PFX/PEM existente
3. Obter — recupera o certificado (apenas chave pública)
4. Atualizar — modifica as propriedades do certificado
5. Excluir — exclusão lógica (recuperável)
6. Purgar — exclusão permanente

Melhores Práticas

1. Use autenticação Entra ID — DeveloperToolsCredential para desenvolvimento
2. Use certificados gerenciados — renovação automática com emissores compatíveis
3. Defina o período de validade adequado — equilibre segurança e manutenção
4. Use políticas de certificado — defina renovação e propriedades de chave
5. Monitore a expiração — configure alertas para certificados que expiram
6. Habilite a exclusão lógica — necessário para cofres de produção

Permissões RBAC

Atribua estas funções do Key Vault:

• Key Vault Certificates Officer — CRUD completo em certificados
• Key Vault Reader — metadados de certificado de leitura

Links de Referência

Quando Usar

Esta habilidade é aplicável para executar o fluxo de trabalho ou as ações descritas na visão geral.

Limitações

• Use esta habilidade apenas quando a tarefa corresponder claramente ao escopo descrito acima.
• Não trate a saída como um substituto para validação específica do ambiente, testes ou revisão especializada.

…