Découvrez comment intégrer Telerik Document Processing aux services cloud Azure et AWS, y compris tout le traitement PDF dont vous aurez besoin dans un environnement sans serveur.
Décharger la génération, la conversion ou la manipulation de documents vers des services cloud vous permet de gérer des charges de travail importantes sans surcharger les ressources sur site. Azure Functions et AWS Lambda évoluent automatiquement en fonction de la demande. Ainsi, que vous ayez besoin de générer 10 ou 10 000 documents, l’infrastructure s’adapte de manière dynamique. Les modèles sans serveur facturent en fonction du temps d’exécution et des ressources consommées, éliminant ainsi le besoin de serveurs dédiés pour le traitement des documents. Ainsi, vous ne payez que ce que vous utilisez.
Cet article de blog présente des démonstrations complètes d’intégration cloud pour Azure et AWS, présentant les capacités de traitement PDF à l’aide de Progress Traitement des documents Telerik dans des environnements sans serveur. Les exemples illustrent deux modèles d’intégration principaux : la fusion de PDF et la signature numérique externe, implémentées pour Azure Functions et AWS Lambda. Les projets de code complets sont disponibles dans notre référentiel SDK : Démonstrations d’intégration cloud.
Intégrer RadPdfProcessing à Azure Functions
Tout d’abord, vous aurez besoin : d’un actif Abonnement Azure, Outils de fonctions Azure installé et le Flux Telerik NuGet installation.
- Créer une application Azure Functions
- Sélectionner Anonyme niveau d’autorisation:
- Installez les packages NuGet suivants :
- Renommez le fichier Functiona1.cs en « MergeFunction » et introduisez votre implémentation personnalisée dans le Courir méthode:
using HttpMultipartParser;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using System.Net;
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
namespace MyAzureFunctionApp;
public class MergeFunction
{
[Function("MergeFunction")]
public async Task<HttpResponseData> Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequestData req)
{
Task<MultipartFormDataParser> parsedFormBody = MultipartFormDataParser.ParseAsync(req.Body);
PdfFormatProvider provider = new PdfFormatProvider();
RadFixedDocument result = MergePdfs(provider, parsedFormBody.Result.Files);
using (MemoryStream outputStream = new MemoryStream())
{
provider.Export(result, outputStream, TimeSpan.FromSeconds(20));
outputStream.Seek(0, SeekOrigin.Begin);
HttpResponseData httpResponseData = req.CreateResponse(HttpStatusCode.OK);
httpResponseData.Headers.Add("Content-Type", "application/pdf");
await outputStream.CopyToAsync(httpResponseData.Body);
return httpResponseData;
}
}
static RadFixedDocument MergePdfs(PdfFormatProvider pdfFormatProvider, IReadOnlyList<FilePart> files)
{
RadFixedDocument mergedDocument = new RadFixedDocument();
foreach (FilePart file in files)
{
RadFixedDocument documentToMerge = pdfFormatProvider.Import(file.Data, TimeSpan.FromSeconds(20));
mergedDocument.Merge(documentToMerge);
}
return mergedDocument;
}
}
Cette fonction Azure, nommée MergeFunctiongère les requêtes HTTP GET et POST pour fusionner plusieurs fichiers PDF en un seul document. Il utilise :
- HttpMultipartParser pour analyser les données d’un formulaire en plusieurs parties et extraire les fichiers téléchargés.
- Telerik PdfFormatProvider et RadFixedDocument pour importer et fusionner des documents PDF.
- Le PDF fusionné est exporté vers un flux mémoire et renvoyé sous forme de réponse HTTP avec le type de contenu application/pdf.
La fonction prend en charge l’accès anonyme et traite efficacement les fichiers téléchargés, de sorte que le PDF fusionné soit livré dans la réponse. Étant donné que la fonction est implémentée avec un accès anonyme à des fins de démonstration, envisagez d’ajouter une authentification si nécessaire pour votre scénario.
- Exécutez le projet et copiez l’URL de la fenêtre qui apparaît :
- Créez une application console .NET (par exemple, MyMergeApp) qui agit en tant que client pour le service Azure Function PDF Merge.
using System.Diagnostics;
using System.Net.Http.Headers;
namespace MyMergeApp
{
internal class Program
{
static void Main(string[] args)
{
string functionUrl = "http://localhost:7163/api/MergeFunction";
string[] pdfFilePaths = { "../../../Resources/file1.pdf", "../../../Resources/file2.pdf" };
using MultipartFormDataContent content = new();
foreach (string filePath in pdfFilePaths)
{
byte[] fileBytes = File.ReadAllBytes(filePath);
ByteArrayContent fileContent = new(fileBytes);
fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/pdf");
content.Add(fileContent, "files", Path.GetFileName(filePath));
}
HttpResponseMessage response = PostAsync(functionUrl, content).Result;
response.EnsureSuccessStatusCode();
byte[] result = response.Content.ReadAsByteArrayAsync().Result;
string outputPath = "merged_output.pdf";
if (File.Exists(outputPath))
{
File.Delete(outputPath);
}
File.WriteAllBytes(outputPath, result);
Process.Start(new ProcessStartInfo(outputPath) { UseShellExecute = true });
}
static async Task<HttpResponseMessage> PostAsync(string url, MultipartFormDataContent content)
{
using HttpClient httpClient = new HttpClient();
httpClient.Timeout = TimeSpan.FromMinutes(2);
return await httpClient.PostAsync(url, content);
}
}
}
Il montre comment envoyer plusieurs fichiers PDF au point de terminaison MergeFunction et gérer le résultat fusionné. Le flux de travail comprend :
- Chargement de fichiers PDF à partir d’un local Ressources annuaire.
- Conditionner les fichiers sous forme de données de formulaire en plusieurs parties pour le téléchargement.
- Envoi d’une requête HTTP POST au point de terminaison Azure Function.
- Réception du PDF fusionné dans la réponse et enregistrement sur le disque.
- Ouverture automatique du PDF fusionné dans la visionneuse par défaut du système.
L’application utilise HttpClient pour la communication, active les en-têtes de type de contenu appropriés et inclut une méthode d’assistancePostAsyncpour envoyer des requêtes avec un délai d’attente configurable.
- Exécutez Azure Functions .NET Worker (par exemple, MyAzureFunctionApp.csproj) :
- Pendant que le service est en cours d’exécution, exécutez l’application console (par exemple, MyMergeApp).
En conséquence, un document PDF fusionné sera produit :
Intégrer RadPdfProcessing à AWS Lambda
L’utilisation d’une fonction AWS Lambda pour signer des documents PDF offre une approche plus sécurisée, évolutive et rentable des flux de travail de signature numérique. En déchargeant le processus de signature vers un environnement sans serveur, les clés privées sensibles restent isolées dans le cloud, réduisant ainsi le risque d’exposition sur les machines clientes.
Le didacticiel suivant définit les étapes de création d’une fonction AWS Lambda qui effectue des opérations de signature numérique pour les documents PDF à l’aide d’une clé privée stockée dans un fichier de certificat. La fonction AWS Lambda est conçue pour agir comme un service plus sécurisé qui signe à distance des documents PDF, et la clé privée n’est jamais exposée au client.
Avant de commencer, vous aurez besoin d’un Informations d’identification AWS et le Flux Telerik NuGet correctement configuré.
- Créez un projet AWS Lambda (par exemple, MyAWSLambda) :
- De la Sélectionnez le plan Assistant, sélectionnez « .NET 8 (Container Image) » :
- Ouvrez le fichier Function.cs et implémentez la logique personnalisée pour signer les documents PDF dans FunctionHandler :
La méthode reçoit les données à signer, les signe à l’aide d’un privé certificat de clé et renvoie la signature codée en Base64. Le certificat .pfx est stocké indépendamment du projet utilisé pour le traitement des documents.
REMARQUE : n’oubliez pas que les données sensibles doivent être stockées correctement et que cette implémentation est à des fins de démonstration.
using Amazon.Lambda.Core;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespace MyAWSLambda;
public class Function
{
public async Task<string> FunctionHandler(Input input, ILambdaContext context)
{
byte[] dataToSign = Convert.FromBase64String(input.DataToSign);
byte[]? result = SignData(dataToSign, input.DigestAlgorithm);
if (result != null)
{
return Convert.ToBase64String(result);
}
else
{
throw new InvalidOperationException("Signing operation failed");
}
}
static byte[]? SignData(byte[] dataToSign, string? digestAlgorithm)
{
string certificateFilePassword = "johndoe";
string certificateFilePath = "Resources/JohnDoe.pfx";
using (Stream stream = File.OpenRead(certificateFilePath))
{
byte[] certRawData = new byte[stream.Length];
stream.ReadExactly(certRawData, 0, (int)stream.Length);
using (X509Certificate2 fullCert = new X509Certificate2(certRawData, certificateFilePassword))
{
using (RSA? rsa = fullCert.GetRSAPrivateKey())
{
if (rsa == null)
{
throw new InvalidOperationException("Certificate does not contain an RSA private key");
}
HashAlgorithmName algorithmName = HashAlgorithmName.SHA256;
algorithmName = digestAlgorithm switch
{
"Sha384" => HashAlgorithmName.SHA384,
"Sha512" => HashAlgorithmName.SHA512,
_ => HashAlgorithmName.SHA256,
};
byte[]? bytes = rsa.SignData(dataToSign, algorithmName, RSASignaturePadding.Pkcs1);
return bytes;
}
}
}
}
public class Input
{
public string DataToSign { get; set; } = string.Empty;
public string? DigestAlgorithm { get; set; }
}
}
- Modifiez le fichier aws-lambda-tools-defaults.json et spécifiez le
function-namepour la fonction AWS Lambda (par exemple,ExternalSignPdfAWSFunction) :
{
"Information": [
"This file provides default values for the deployment wizard inside Visual Studio and the AWS Lambda commands added to the .NET Core CLI.",
"To learn more about the Lambda commands with the .NET Core CLI execute the following command at the command line in the project root directory.",
"dotnet lambda help",
"All the command line options for the Lambda command can be specified in this file."
],
"profile": "telerik-dpl",
"region": "eu-north-1",
"configuration": "Release",
"package-type": "image",
"function-memory-size": 512,
"function-timeout": 30,
"image-command": "MyAWSLambda::MyAWSLambda.Function::FunctionHandler",
"docker-host-build-output-dir": "./bin/Release/lambda-publish",
"function-name": "ExternalSignPdfAWSFunction"
}
-
Créez une application console (par exemple, MySigningApp.csproj) qui consommera la fonction AWS Lambda.
-
Installez les packages NuGet suivants :
- AWSSDK.Lambda
- Telerik.Documents.Corrigé
Le Ressources Le dossier stocke le document PDF non signé avec le certificat public .crt.
- Modifiez le fichier Program.cs pour montrer comment appliquer une signature numérique à un document PDF à l’aide de Telerik Traitement PDFbibliothèque et un signataire AWS Lambda externe. Le flux de travail comprend l’importation d’un PDF, la création d’un champ de signature avec une représentation visuelle, configuration des paramètres de signature et exportation du document signé.
Remarque : Nous utiliserons le spécifié function-name à l’étape précédente lors de la création du LambdaFunctionSigner objet:
using System.Diagnostics;
using Telerik.Documents.Fixed.Model.DigitalSignatures;
using Telerik.Documents.Primitives;
using Telerik.Windows.Documents.Fixed.FormatProviders.Pdf;
using Telerik.Windows.Documents.Fixed.Model;
using Telerik.Windows.Documents.Fixed.Model.Annotations;
using Telerik.Windows.Documents.Fixed.Model.DigitalSignatures;
using Telerik.Windows.Documents.Fixed.Model.Editing;
using Telerik.Windows.Documents.Fixed.Model.InteractiveForms;
using Telerik.Windows.Documents.Fixed.Model.Objects;
using Telerik.Windows.Documents.Fixed.Model.Resources;
namespace MySigningApp
{
internal class Program
{
static void Main(string[] args)
{
PdfFormatProvider provider = new PdfFormatProvider();
RadFixedDocument document = ImportDocument(provider);
string signatureName = "SampleSignature";
Form form = new Form();
form.FormSource = new FormSource();
form.FormSource.Size = new Size(120, 120);
FixedContentEditor formEditor = new FixedContentEditor(form.FormSource);
formEditor.DrawCircle(new Point(50, 50), 20);
formEditor.DrawText(signatureName);
SignatureField signatureField = new SignatureField(signatureName);
ExternalSignerBase externalSigner = new LambdaFunctionSigner("ExternalSignPdfAWSFunction", "eu-north-1");
Signature signature = new Signature(externalSigner);
signature.Settings.DigestAlgorithm = DigestAlgorithmType.Sha512;
signature.Settings.TimeStampServer = new TimeStampServer("http://timestamp.digicert.com", TimeSpan.FromSeconds(10));
signatureField.Signature = signature;
SignatureWidget widget = signatureField.Widgets.AddWidget();
widget.Rect = new Rect(200, 600, 100, 100);
widget.Border = new AnnotationBorder(100, AnnotationBorderStyle.Solid, null);
widget.Content.NormalContentSource = form.FormSource;
RadFixedPage page = document.Pages.AddPage();
page.Annotations.Add(widget);
document.AcroForm.FormFields.Add(signatureField);
document.AcroForm.SignatureFlags = SignatureFlags.AppendOnly;
ExportDocument(provider, document);
}
static RadFixedDocument ImportDocument(PdfFormatProvider provider)
{
using (FileStream stream = File.OpenRead("Resources/SampleDocument.pdf"))
{
return provider.Import(stream, TimeSpan.FromSeconds(20));
}
}
static void ExportDocument(PdfFormatProvider provider, RadFixedDocument document)
{
string outputPath = "ExternallySignedDocument.pdf";
File.Delete(outputPath);
using (FileStream stream = File.Create(outputPath))
{
provider.Export(document, stream, TimeSpan.FromSeconds(60));
}
Process.Start(new ProcessStartInfo(outputPath) { UseShellExecute = true });
}
}
}
- Implémentez le signataire externe.
Le LambdaFunctionSigner La classe est une implémentation personnalisée d’un signataire externe qui délègue les opérations de signature numérique à une fonction AWS Lambda. Il hérite de Base de signataire externeet est conçu pour les scénarios dans lesquels la clé privée est stockée en toute sécurité dans AWS Lambda, tandis que le certificat public réside localement.
using Amazon.Lambda;
using Amazon.Lambda.Model;
using Amazon.Runtime;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.Json;
using Telerik.Documents.Fixed.Model.DigitalSignatures;
namespace MySigningApp
{
public class LambdaFunctionSigner : ExternalSignerBase
{
private readonly string functionName;
private readonly AmazonLambdaClient lambdaClient;
public LambdaFunctionSigner(string functionName, string region)
{
this.functionName = functionName;
var credentials = new BasicAWSCredentials("your-access-key", "your-secret-key");
this.lambdaClient = new AmazonLambdaClient(credentials, Amazon.RegionEndpoint.GetBySystemName(region));
}
protected override X509Certificate2[] GetCertificateChain()
{
string publicKey = "Resources/JohnDoe.crt";
return [new X509Certificate2(publicKey)];
}
protected override byte[] SignData(byte[] dataToSign, SignatureSettings settings)
{
var requestData = new
{
DataToSign = Convert.ToBase64String(dataToSign),
DigestAlgorithm = settings.DigestAlgorithm.ToString()
};
string jsonRequest = JsonSerializer.Serialize(requestData, new JsonSerializerOptions
{
WriteIndented = true
});
var invokeRequest = new InvokeRequest
{
FunctionName = this.functionName,
InvocationType = InvocationType.RequestResponse,
Payload = jsonRequest
};
InvokeResponse invokeResponse = lambdaClient.InvokeAsync(invokeRequest).Result;
if (invokeResponse.StatusCode != 200)
{
throw new InvalidOperationException($"Lambda invocation failed with status code: {invokeResponse.StatusCode}");
}
if (!string.IsNullOrEmpty(invokeResponse.FunctionError))
{
string errorMessage = Encoding.UTF8.GetString(invokeResponse.Payload.ToArray());
throw new InvalidOperationException($"Lambda function error: {invokeResponse.FunctionError}. Details: {errorMessage}");
}
string jsonResponse = Encoding.UTF8.GetString(invokeResponse.Payload.ToArray());
string? base64Signature = JsonSerializer.Deserialize<string>(jsonResponse);
if (string.IsNullOrEmpty(base64Signature))
{
throw new InvalidOperationException("Invalid response from Lambda function");
}
return Convert.FromBase64String(base64Signature);
}
}
}
- Exécutez le projet.
En conséquence, le document PDF non signé est signé avec succès :
Conclusion
L’intégration de Telerik Document Processing avec Azure Functions et AWS Lambda démontre comment les architectures sans serveur peuvent transformer les flux de travail documentaires. En tirant parti de l’évolutivité du cloud et des modèles de paiement à l’utilisation, les organisations peuvent gérer efficacement des tâches telles que la fusion de PDF et la signature numérique sécurisée sans maintenir une infrastructure dédiée. Ces approches réduisent non seulement les frais opérationnels, mais améliorent également la sécurité en isolant les clés sensibles dans le cloud.
À mesure que les entreprises continuent d’adopter des solutions distantes et distribuées, des modèles similaires peuvent être étendus à d’autres flux de travail tels que la conversion de documents, le filigrane et le traitement par lots, offrant ainsi une flexibilité et une rentabilité encore plus grandes. Les exemples fournis servent de base à la création de services documentaires robustes, alimentés par le cloud, qui s’adaptent parfaitement à la demande.
Essayez le Bibliothèques de traitement de documents Telerikqui sont inclus dans le Offres groupées Telerik DevCraft pour s’associer parfaitement à vos bibliothèques de composants préférées.
Source link