CRUD Operations with Azure Table Storage in an Azure Function – R

In an earlier post, we discussed how to insert a new item in the Azure Storage Table. In this article, we will delve into how to retrieve data from Azure Storage Table.

Retrieve a Single Entity

In the previous article, we had partitioned the entities based on their first letter of their Title. Here is how our table looked at end our insert operations.

As mentioned before, we would use CloudTable to retrieve the entity we desire. For the sake of example, let us assume that the RowKey of the desired record would be passed via QueryString in the Http Request.

[FunctionName("TodoGetOne")]
public static async Task<IActionResult> GetOne(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
[Table("todos")] CloudTable todoTable,
ILogger log)
{
    string id = req.Query["id"];

    var tableQuery = new TableQuery<TodoTableEntity>();

    tableQuery.FilterString = TableQuery.CombineFilters(
        TableQuery.GenerateFilterCondition(nameof(TableEntity.PartitionKey), QueryComparisons.NotEqual, "Key"), 
        TableOperators.And, 
        TableQuery.GenerateFilterCondition(nameof(TableEntity.RowKey), QueryComparisons.Equal, id));

    var result = todoTable.ExecuteQuery(tableQuery);
    return new OkObjectResult(result);
}

As you can observe, we have used the TableQuery to filter our desired entity.

var tableQuery = new TableQuery<TodoTableEntity>();

tableQuery.FilterString = TableQuery.CombineFilters(
    TableQuery.GenerateFilterCondition(nameof(TableEntity.PartitionKey), QueryComparisons.NotEqual, "Key"), 
    TableOperators.And, 
    TableQuery.GenerateFilterCondition(nameof(TableEntity.RowKey), QueryComparisons.Equal, id));

The TableQuery.FilterString property enables us to provide Custom filters for the query. This is further facilitated by supporting utility methods in TableQuery, such as CombineFilters, and GeneratedFilterCondition. In our case, as seen in code above, we are filtering the data where the PartitionKey is not equal to text Key (remember, the partition key in our example is a special partition which keeps track of next Primary Id available ) and RowKey equavalent to the Id passed via querystring.

Further, we execute the query using the CloudTable.ExecuteQuery method.

var result = todoTable.ExecuteQuery(tableQuery);

That’s all you would need to fetch the data from Azure Table Storage.

Retrieve One Entity Using Binding

Table Binding also helps us retrieve a single record skipping a lot of boiler plate code, provided we know the parition key and the row key. For example, consider the following code.

[FunctionName("TodoGetOneBinding")]
public static async Task<IActionResult> TodoGetOneBinding1(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = "TodoGetOneBinding/{partition}/{id}")] HttpRequest req,
[Table("todos", "{partition}", "{id}")] TodoTableEntity todo,
ILogger log)
{
    return new OkObjectResult(todo);
}

This effectively does the same as the code in our previous example, but provides a less cluttered code. The {parition} and {id} parameters from the Route is used as parameters for filter the table here.

Retrieve Multiple Entities

I guess there is very little to explain here once we have done the above examples. So let us write the code straightaway for retrieve all the todo items

[FunctionName("TodoGetAll")]
public static async Task<IActionResult> GetAll(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
    [Table("todos")] CloudTable todoTable,
    ILogger log)
{
    var tableQuery = new TableQuery<TodoTableEntity>();
    tableQuery.SelectColumns = new List<string> { nameof(TodoTableEntity.Description) };
    tableQuery.FilterString = TableQuery.GenerateFilterCondition(nameof(TableEntity.PartitionKey), QueryComparisons.NotEqual, "Key");

    var result = todoTable.ExecuteQuery(tableQuery);
    return new OkObjectResult(result);
}

That’s all for now. We will continue our journey exploring the Azure Cloud Storage in upcoming articles.

Deploy Github Sub Directory To Azure

In this blog post, I would walk you through publishing a sub directory of your Github repository to the Azure.

The first step would be to head over to your desired Resource Group in Azure Portal and Create a Web App Resource.

For sake of demonstration, we would be publishing a web portal build using VueJS. For the same reason, we are using a Runtime of Node 12 LTS.

Once you have created the Web App resource, head over to Deployment Center and choose Github under the Continuous Deployment Section.

If you are doing this for the first, you might be prompted to Authenticate your Github Account. Next, you need to Build Provider. We will choose Github Actions in here.

This would lead you to the following screen, which would help in choosing your repository.

The Add or overwrite workflow definition would generate the Github workflow for deployment. This looks something similiar to the following.

name: Build and deploy Node.js app to Azure Web App

on:
  push:
    branches:
      - main

jobs:
  build-and-deploy:
    runs-on: windows-latest

    steps:
    - uses: actions/checkout@master

    - name: Set up Node.js version
      uses: actions/setup-node@v1
      with:
        node-version: '12.13.0'

    - name: npm install, build, and test
      run: |
        npm install
        npm run build --if-present
        npm run test --if-present


    - name: 'Deploy to Azure Web App'
      uses: azure/webapps-deploy@v2
      with:
        app-name: 'yourappName'
        slot-name: 'production'
        publish-profile: ${{ secrets.YourSecretKey }}
        package: .

As you have noticed, the workflow also contains a secret key which would be used for authenticating the publish action.

So far, this has been quite similiar to how you would publish an entire repository in Github to Azure. But as mentioned earlier, we are particularly interested in publishing a sub directory in the Github repository. For this purpose, we will begin by ensuring the npm build actions are done within the particular sub directory.

For the same, we modify the workflow, with the following changes.

    - name: npm install, build, and test
      run: |
        npm install
        npm run build --if-present
        npm run test --if-present
      working-directory: portalDirectory/subDirectory


As you can observe, we have instructed the action to use a particular working directory while running the NPM scripts. However, we are not done yet.

Just like we ensured the npm build is done against the desired folder, we also need to ensure that only the desired sub folder gets published.

If you attempt to use working-directory with the ‘Deploy to Azure Web App’ Step in the action, you would be prompted with an error that working-directory cannot be used with an action that contains a with statement.

The .deployment file comes to our rescue at this point. The .deployment file needs to be created in the root of your repository. We will add the following contends to the file.

[config]
project = portalDirectory/subDirectory/dist

That would be all you need. The .deployment file would instruct the CI/CD process to deploy the contends of the portalDirectory/subDirectory/dist directory to Azure.

I hope that did help you.

CRUD Operations with Azure Table Storage in an Azure Function – C

In this series of byte sized tutorials, we will create an Azure Function for Crud Operations on an Azure Storage Table. For the demonstration, we will stick a basic web function, which would enable us to do the CRUD operations for a TODO table.

The reason to pick Azure Storage table is primarly it is extremely cost efficient and you could also emulate the storage within your development environment.That’s true, you do not need even a Azure subscription to try out Azure Storage, thanks the Storage Emulator.

One of the key points to remember before we proceed is how an Entity is identified uniquely in a Azure Table Storage. Partitions allows scaling of the system easily and whenever you store an item in the table, it is stored in a partition, which is scaled out in the system. The PartionId allows to uniquely identify the partition in which the data resides. The RowId, uniquely identifies the specific entity within the Partition and together with ParitionKey forms the composite key that would be unique identifier for your entity.

We will get back to this a bit later. But for now, we will define our Entity derieved from TableEntity.

using Microsoft.Azure.Cosmos.Table;
public class TodoTableEntity : TableEntity
{
    public string Title { get; set; }
    public string Description { get; set; }
    public bool IsCompleted { get; set; }
}

We require 3 columns in our Table in addition to the PartionKeyRowKey, and TimeStamp.

We will begin by writing the basic skeleton code for our web function and go through the key components, before the insert operation.

[FunctionName("TodoAdd")]
public static async Task<IActionResult> Add(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
    [Table("todos")] CloudTable todoTable,
    ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    var data = JsonConvert.DeserializeObject<TodoDto>(requestBody);

    // TODO

    return new OkObjectResult(0);
}

public class TodoDto
{
    public string Title { get; set; }
    public string Description { get; set; }
    public bool IsCompletd { get; set; }
}

The function defined above (TodoAdd) accepts a HttpTrigger (both Get and Post requests). The data to be inserted is passed via the Request Body. We will use the HttpRequest.Body property to read the information and deserialize them. This is quite evident in the code above. What is of more interest at this point is the todoTable parameter.

The todoTable parameter, of type CloudTable represents a table in Microsoft Azure Table Service and provides us all the methods required to access the table. The bindings specify that the table is named todos.

Now that we have our data to be deserialized and the table name, we would proceed to insert the data in the table.

var dataToInsert = new TodoTableEntity
{
    Title = data.Title,
    Description = data.Description,
    IsCompleted = data.IsCompletd,
    PartitionKey = data.Title[0].ToString(),
    RowKey = data.Title[0].ToString()
};


var addEntryOperation = TableOperation.Insert(dataToInsert);
todoTable.CreateIfNotExists();
await todoTable.ExecuteAsync(addEntryOperation);


As mentioned earlier the CloudTable provides us with all the necessary ammuniation to access the table. In this case, we would be using the CloudTable.ExecuteAsync method to execute a TableOperation to insert the record.

However, the following code has a serious flaw, which we will discuss in a moment. Consider the Entity we are about to insert.

var dataToInsert = new TodoTableEntity
{
    Title = data.Title,
    Description = data.Description,
    IsCompleted = data.IsCompletd,
    PartitionKey = data.Title[0].ToString(),
    RowKey = data.Title[0].ToString() // This causes an error
};

After filling the Title,Description and IsCompleted fields from the data we recieved from the Http Request, we are also assigning the PartitionKey and RowKey to the entity. We have decided, for the sake of example, to partition the table based the first alphabet of the Title. This works fine – we would end up with multiple partitions. However, the RowKey would cause an issue. Consider the following two requests.

// First Request
{
    title:'A Test',
    description:'A Test Description`,
    isCompleted:'false`
}
// Second Request
{
    title:'Another Test',
    description:'A Test Description`,
    isCompleted:'false`
}

Both these request would have PartitionKey value as “A” according to the code we wrote above. This is fine, as would want to group all the Entities with title starting with “A” in the same partition. However, the above code would also result in both the RowId to be same as well. This leads to an error as these needs to be separate entities and cannot share the same combination of PartitionKey and RowId.

For this reason, we will need a unique Id to identify the RowId. In this example, we will use a simple technique in which we will create another partition, namely Key, which would contain a single Row. This Row would contain a numerical value which we would use as the Identity value to be used in the table. With each request, we would also need to update the key.

So let us rewrite the code again to make use of the Key entity.

[FunctionName("TodoAdd")]
public static async Task<IActionResult> Add(
    [HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
    [Table("todos","Key","Key",Take =1)] TodoKey keyGen,
    [Table("todos")] CloudTable todoTable,
    ILogger log)
{
    log.LogInformation("C# HTTP trigger function processed a request.");

    string name = req.Query["name"];

    string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
    var data = JsonConvert.DeserializeObject<TodoDto>(requestBody);

    if (keyGen == null)
    {
        keyGen = new TodoKey
        {
            Key = 1000,
            PartitionKey = "Key",
            RowKey = "Key"
        };

        var addKeyOperation = TableOperation.Insert(keyGen);
        await todoTable.ExecuteAsync(addKeyOperation);
    }

    var rowKey = keyGen.Key;

    var dataToInsert = new TodoTableEntity
    {
        Title = data.Title,
        Description = data.Description,
        IsCompleted = data.IsCompletd,
        PartitionKey = data.Title[0].ToString(),
        RowKey = keyGen.Key.ToString()
    };

    keyGen.Key += 1;
    var updateKeyOperation = TableOperation.Replace(keyGen);
    await todoTable.ExecuteAsync(updateKeyOperation);
    var addEntryOperation = TableOperation.Insert(dataToInsert);
    todoTable.CreateIfNotExists();
    await todoTable.ExecuteAsync(addEntryOperation);

    return new OkObjectResult(keyGen.Key);
}

As observed in the code above, we have introduced a new parameter keyGen, which points to the new entity in the same todos table. We have used the bindings to specify the ParitionKey and RowKey to fetch the entity for us.

We then increment the Key, and use it as the RowId for rest of our entities. The resultant table storage would look like following.

In this example, we have create a simple Create Operation for Azure Table Storage. We will explore more into the Azure Bindings and rest of CRUD Operations in rest of the series, but hope this provides a good starting point for learning Azure Storage with Azure functions.