Developing and Deploying C# HTTP Trigger Azure Functions

1. Creating the Azure Functions Project

Your primary tool for this task will be Visual Studio. The Azure development workload you installed earlier includes templates and tools specifically for Azure Functions. We'll start by creating a new project from a template.

As you went through the setup, you made several important choices. Let's clarify them:

• Functions worker: .NET 8.0 Isolated (Long Term Support): This is the modern and recommended model for .NET functions. It runs your function code in a separate worker process from the Functions host runtime. This provides better dependency management and lets you use the latest .NET versions as soon as they are released, without being tied to the runtime's .NET version.
• Function: HTTP trigger: This template generates boilerplate code for a function that responds to HTTP requests, essentially creating a serverless API endpoint.
• Authorization level: Anonymous: For local testing, this is the simplest option, as it doesn't require any security keys to call your function's endpoint. When we deploy to Azure, we will see how Function level authorization works, which requires an API key.

2. Understanding the Code

Visual Studio has generated a few files for you. Let's examine the most important one: Function1.cs (or whatever you named it).

The core of the function lies in the Run method and its attributes.

[Function("Function1")]
public IActionResult Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post")] HttpRequest req)
{
    _logger.LogInformation("C# HTTP trigger function processed a request.");
    return new OkObjectResult("Welcome to Azure Functions!");
}

• [Function("Function1")]: This attribute registers your method with the Functions runtime. The string you provide becomes the name of the function as it appears in the Azure portal. It's good practice to rename this to match your C# method name.
• [HttpTrigger(...)]: This is the trigger binding. It tells the runtime that this function should be executed by an incoming HTTP request.
  • AuthorizationLevel.Anonymous: As discussed, this means no key is needed. Other options are Function (requires a function-specific or master key) and Admin (requires the master key).
  • "get", "post": These specify the allowed HTTP methods. You can customize this array to support any required verbs, just like in a traditional REST API.
• HttpRequest req: The runtime passes an HttpRequest object into your function, giving you access to the request headers, body, query parameters, etc.

For better code organization, let's quickly rename the function as the quickstart suggests.

3. Running and Testing Locally

One of the most powerful features of Azure Functions development in Visual Studio is the ability to run and debug your code locally. When you press F5, Visual Studio launches the Azure Functions Core Tools, which is a local version of the full Azure Functions runtime.

Let's see this in action.

Now, try it yourself.

1. Press F5 in Visual Studio to start debugging.
2. A console window will appear, displaying startup messages from the Functions runtime.
3. Once it's running, you will see a list of your available HTTP functions and their local URLs, like this:
   HttpExample: [GET,POST] http://localhost:7071/api/HttpExample
4. Copy this URL, paste it into a browser, and press Enter.

You should see the "Welcome to Azure Functions!" message returned by your function. You have just successfully run a serverless function on your local machine! To stop the debugger, press Shift+F5 in Visual Studio.

4. Deploying to Azure

Now that we've confirmed the function works locally, the next step is to deploy it to Azure. The Visual Studio publish wizard simplifies this by allowing you to create all the necessary Azure resources and deploy your code in one flow.

We will publish our function to a Consumption Plan, which embodies the true serverless model we discussed in the previous lesson—it scales automatically and you only pay for what you use.

To perform the deployment, follow these steps, also detailed in the "Publish the project to Azure" section of the Quickstart (LINK):

1. In Solution Explorer, right-click the project and select Publish.
2. Follow the wizard:
   • Target: Azure
   • Specific target: Azure Function App (Windows)
   • Functions instance: Click + Create new.
3. In the "Create new" dialog:
   • Name: Give your Function App a globally unique name (e.g., az204-func-YourInitials-Date).
   • Resource Group: Create a new one to keep your resources organized.
   • Plan Type: Select Consumption.
   • Location: Choose a region near you.
   • Azure Storage: Create a new storage account.
4. Click Create. Visual Studio will now provision these resources in your Azure subscription. This may take a few minutes.
5. Once the resources are created and the publish profile is ready, click the Publish button.

Visual Studio will build your project, package it into a zip file, and deploy it to the Function App you just created.

5. Verifying the Function in Azure

Your code is now live in Azure! To test it, you need to get its public URL. Because we didn't specify an authorization level during publish, it defaults to Function level. This means you need a security key to call it.

As you saw, the URL for the deployed function looks something like this:

https://<your-app-name>.azurewebsites.net/api/HttpExample?code=...<a_long_secret_key>...

The code query parameter is the function key that grants access. This simple key-based security is sufficient for machine-to-machine communication, like the webhook scenario Tim Corey demonstrated in his video. When you paste this full URL into your browser, you should see the same successful response you saw locally.

Important: Don't forget to clean up your resources by deleting the resource group you created once you are finished experimenting.

Conclusion

Congratulations! You have successfully built and deployed a serverless API endpoint using Azure Functions and C#. You experienced the end-to-end developer workflow, from local coding and debugging in Visual Studio to a one-click publish process that provisions all necessary cloud infrastructure.

Key Takeaways:

• Visual Studio provides a rich, integrated experience for developing Azure Functions, including project templates and local debugging via the Azure Functions Core Tools.
• The C# function model uses attributes like [Function] and [HttpTrigger] to define a function and its entry point declaratively.
• Publishing from Visual Studio can automatically create the Function App, a Consumption Plan, and a Storage Account in Azure.
• Functions deployed to Azure are typically secured with Function level authorization, requiring an API key in the request URL.

Next Steps

So far, our function only returns a static string. In the next lesson, we will make it far more powerful. We'll explore the next learning outcome: Configure input and output bindings to connect an Azure Function to Azure Storage. You'll see how bindings allow your function to read from and write to other Azure services with minimal code, unlocking the true potential of the serverless model.