Transfer blob by SAS URI in Azure functions

I'm working on Azure functions application, written in C#. One from my tasks is to create a function which will copy a blob to another storage account using SAS uri for accessing the source blob. Important to wait until operation is completed (or failed) and make appropriate changes in database.
But there is a potential problem: copy operation could take longer than allowed for activity function. The solution could be using a durable function for starting copying and monitoring its status. But I have no idea how to orchestrate such process in a proper way: what to pass to "copy" activity, what to return for passing into "check" activity... I'm sorry for this lame question, but I'm new in Azure functions. I'll appreciate all suggestions.

Update:

Inspired with suggestion from Kristin, I've developed the following orchestration:

[FunctionName("UploadProjectBlob")]
public async Task RunOrchestrator(
[OrchestrationTrigger] IDurableOrchestrationContext context,
ILogger log)
{
string sourceSas = "https://...";
string destination = $"test/bigfile_{context.CurrentUtcDateTime.Ticks}.dat";
await context.CallActivityAsync(nameof(StartCopying), (sourceSas, destination));
bool done = false;
bool success = false;
do
{
DateTime fireAt = DateTime.UtcNow + TimeSpan.FromSeconds(60);
await context.CreateTimer(fireAt, CancellationToken.None);
var status = await context.CallActivityAsync<CopyStatus>(nameof(CheckStatus), destination);
switch (status)
{
case CopyStatus.Pending:
// not done, continue the loop
continue;
case CopyStatus.Success:
// handle completed copy
done = success = true;
break;
case CopyStatus.Failed:
// handle failed copy
done = true;
break;
case CopyStatus.Aborted:
// handle aborted copy
done = true;
break;
// in case new values are added to the BlobCopyStatus
default:
throw new Exception($"Unknown blob copy status {status}");
}
} 
while (!done);
if (success)
{
log.LogInformation("Copy success");
}
else
{
log.LogInformation("Copy failed");
}
}
[FunctionName(nameof(StartCopying))]
public void StartCopying(
[ActivityTrigger] IDurableActivityContext inputs, 
ILogger log)
{
var (sas, destination) = inputs.GetInput<(string, string)>();
var blobClient = CreateBlobClient(destination);
_ = blobClient.StartCopyFromUriAsync(new Uri(sas));
}
[FunctionName(nameof(CheckStatus))]
public async Task<CopyStatus> CheckStatus(
[ActivityTrigger] IDurableActivityContext inputs,
ILogger log)
{
var destination = inputs.GetInput<string>();
var blobClient = CreateBlobClient(destination);
var properties = await blobClient.GetPropertiesAsync();
var status = properties.Value.BlobCopyStatus ?? CopyStatus.Failed;
return status;
}
public BlobClient CreateBlobClient(string name)
{
BlobServiceClient blobServiceClient = new BlobServiceClient(Environment.GetEnvironmentVariable("STORAGE_CS"));
BlobContainerClient blobContainerClient = blobServiceClient.GetBlobContainerClient("emails");
return blobContainerClient.GetBlobClient(name);
}

It works for me and seems safe from the point of timeouts in activity functions. But I'll appreciate feedback from people who have experience in Azure functions. Is such solution safe? Can I be somehow improved?

I'm guessing you've looked into how to actually create Durable Functions, and that you know how OrchestrationTrigger and ActivityTrigger are built.

The jest of it is to use await blobClient.StartCopyFromUriAsync(uri) in your ActivityTrigger.

The blobClient instance where you invoke this method on, should be the destination storage account.

The uri variable must be the source blob, including a SAS token (that is, the URI will be something like https://uri.to.source.storage/blob-location?sasToken=value). Remember to give read access when you build this SAS token.

In your ActivityTrigger you'd start the copy operation, and subsequently query the copy operation's current status using blobClient.GetPropertiesAsync, and accessing the properties.Values.BlobCopyStatus.

A simple example of how it would look like in your ActivityTrigger:

// start copy operation
_ = await destinationBlobClient.StartCopyFromUriAsync(sourceBlobUriWithSasToken);

// keep querying the status until we get something we 
while (true)
{
    // to avoid spamming this over and over, only query the 
    // properties once per 5 seocnds
    await Task.Delay(TimeSpan.FromSeconds(5));

    // get the copy status and handle accordingly
    var properties = await destinationBlobClient.GetPropertiesAsync();
    switch (properties.Value.BlobCopyStatus)
    {
        case Azure.Storage.Blobs.Models.CopyStatus.Pending:
            // not done, continue the loop
            continue;

        case Azure.Storage.Blobs.Models.CopyStatus.Success:
            // handle completed copy
            break;

        case Azure.Storage.Blobs.Models.CopyStatus.Failed:
            // handle failed copy
            break;

        case Azure.Storage.Blobs.Models.CopyStatus.Aborted:
            // handle aborted copy
            break;

        // in case new values are added to the BlobCopyStatus
        default:
            throw new UnknownBlobCopyStatusException(properties.Value.BlobCopyStatus);
    }
}

I'm not sure if it's better, but an alternative is to have a regular Function that starts the blobClient.StartCopyFromUriAsync and immediately returns. Then have a BlobTrigger, that is generic enough to listen to any changes for your destination account storage (if the destination storage account is variable, then I'm not sure this approach is possible, due to the limited BlobTrigger-pattern matching). I don't remember if BlobCopyStatus triggers a BlobTrigger, which of course is also necessary for this alternative to be viable. You could test it yourself. In any case, if the previous mentioned things are non-issues, then you could do something like this as well:

[FunctionName("BlobCopyStatusListener")]
public static async Task Bleh(
    [BlobTrigger("destination-pattern")] BlobClient blobClient)
{
    var properties = await blobClient.GetPropertiesAsync();
    switch (properties.Value.BlobCopyStatus)
    {
        ...
    }
}