Azure Function, Logic Apps & Blob Storage for .NET Developer

Azure storage provides a scalable, durable cloud drive, replicates data across locations, and secures access with a shared access signature, while offering global access and NuGet packages for .NET developers.

Explore Azure storage types with a focus on blob storage, learning how blobs store unstructured data as objects and how access tiers—hot, cold, and archive—balance cost and performance.

Explore the Azure blob storage hierarchy, with unique storage account names, containers like dotnet mastery-pdf and images, unique blob URLs, and access levels—private, blob, and full container—with virtual directories.

Create and configure an azure storage account for blob storage in the portal, choosing subscription, resource group, region, redundancy (LRS or GRS), security (SAS key), and review deploy.

Create and manage a blob container in a storage account, set access levels, upload images, and explore blob URLs and shared access signatures for access control.

Upload and organize images as block blobs in a container, choosing block blob type, setting hot access tier, and using virtual folders to create structured, retrievable URLs.

Create a dotnet mvc project to integrate with an azure storage account, naming the solution azure fundamentals and the project azure blob project, using dotnet 10 with no authentication.

Secure blob storage by making the container private and using storage account access keys, then add the copied connection string to appsettings.json under blob connection.

Install the Azure Storage Blob NuGet package, configure a singleton Blob service client in program.cs, and inject it into controllers to use the blob connection string from app settings.

Design an Azure container service using the repository pattern to manage blob containers. Expose endpoints to list containers and blobs, create by name, and delete by name, with singleton DI.

Explore retrieving all blob storage container names by leveraging the blob service client via dependency injection, asynchronously listing containers, and returning their names in an API endpoint.

Learn to create and delete blob containers using the blob service client, retrieving a blob container client by name and calling create if not exist async with access type options.

Create a container controller and use dependency injection to call a container service, retrieve all Azure blob storage containers via the index endpoint, and verify the blob storage connection.

Create the container index view to display all blob container names from a string list, with create, manage, and delete actions and null model validation to prevent exceptions.

Implement create and delete containers for Azure Blob Storage in a .NET app by adding a container model, post create endpoint, and delete endpoint, with redirects to refresh the list.

Implement a blob service interface to list blobs in a container, fetch blob URLs, and manage a blob model with URI, title, and comment; support create, upload, and delete operations.

Implement a blob service endpoint to list all blobs in a container by injecting a blob container client, calling Get blobs async, and returning the blob names.

Retrieve a blob by name using the blob container client and return its absolute uri. Delete a blob if it exists with an async operation and return a boolean.

Create a blob by obtaining blob container client and blob client, set content type in HTTP headers, upload from a read stream, and return true on success or false otherwise.

Create a blob controller to manage blob retrieval, inject the blob service, and expose a get endpoint that retrieves all blobs by container name and their absolute URIs.

Manage blob view displays blobs in a table using a string list from a template and a container name from the query string, with add and delete buttons.

Create a blob upload view with a get endpoint named add file and a multipart form data file upload, then run the app to verify the blob item.

Learn to pass the container name via route parameters and query strings for blob operations, and use a hidden field to keep context for add, view, and delete actions.

Demonstrates a post endpoint for uploading files to blob storage, validates file, appends a random grid to the file name while preserving its extension, and saves via the blob service.

View and delete blobs via the blob controller and service, using get blob and delete blob endpoints. Handle container access levels, public or private, and enforce seven-day retention with undelete.

Display the storage account hierarchy by listing all containers and their blobs on the home page, showing account name, container name, and blob items via async endpoints.

Add metadata to a blob image in Azure portal using key–value pairs, such as title and comment, save, and verify eight kilobytes of metadata persists for access in dotnet application.

Retrieve blob metadata by iterating container blobs, obtaining a blob client for each name, calling get properties async, and displaying the title metadata alongside the image.

Bind the blob model with title and comment fields, and build a metadata dictionary. Pass the metadata to the upload process to store metadata with the blob in the container.

Learn to remove or update blob metadata using set metadata with an empty dictionary, and explore multiple approaches to manage title and comment fields in blob storage.

Create a new container named dotnet mastery dash private and set its access level to container, then upload an image and verify the container appears after refreshing.

Retrieve blobs with uri and metadata to display image titles by iterating the container, extracting each blob's uri and title metadata, and returning a list of blob models.

Fetch and display images from a private container via an async endpoint that returns uri and optional title, rendered in a simple view.

Learn to generate a shared access signature (sas) for Azure blob storage, set read permissions and time-bound access, and access the resource via a sas url in dotnet.

Display private images using a SAS URI by configuring a blob SAS builder, granting read permission for one hour, and generating a SAS URI.

Generate a sas uri at the container level for a .net app using the container client to grant read access with one-hour expiry.

Generate a storage account level SAS in portal.azure.com, configuring services, resources, permissions, IP restrictions, and expiry, then update app settings with the SAS connection string.

Organize the blob storage project by creating an Azure blob example folder and moving the solution inside, ensuring you can continue seamlessly with the next topic.

Create a new folder in the solution, add an mvc project named azure function daniweb with dotnet ten, set as startup project, and run to verify it works.

Create a sales request model with id, name, email, phone, and status, and a form with submit and resume upload in the index view, using the azure function snippet.

Explore Azure function hosting options, including consumption, flex consumption, premium, app service plan, and container app environment, and learn how each handles cold starts, scale, and cost.

Create an Azure function app in Visual Studio, choose dotnet nine isolated, configure an http trigger, and explore anonymous authorization with the local Azure storage emulator.

Explore building an Azure function app with a single http-triggered function, using program.cs, host.json, and Local.settings.json to configure the dotnet isolated runtime.

Rename Azure function to handle sales uploads and write to the queue. Configure keys and connection strings, then invoke the function from the web app.

Call the Azure function from a web project by wiring an HTTP client factory into the index post action, then invoke the function endpoint to trigger processing.

Pass sales details from the web project to the Azure function by serializing the sales object with JSON, posting it via HTTP, and returning the response to the index page.

Create a sales request model in the Azure Function and deserialize the http request body, read with a stream reader, into that model using JSON convert.

Configure an output binding to an Azure storage queue from the function, specify the sales request outbound queue name and connection string, and push messages.

Create and connect a local sql table for use with azure function, detailing local and azure database setup, connection strings, and a sales request table.

Create a DbContext and EF Core setup to populate a SQL database from a queue-triggered Azure function, defining a sales request DbSet and its primary key.

Bind the application DbContext in Program.cs and register it with builder.Services. Configure UseSqlServer with the connection string sourced from local.settings.json.

Create a queue-triggered Azure function in the function app to populate the SQL database from inbound messages, injecting the application DB context and updating the database from the message body.

Deserialize the sales request from the message body, insert it into the database with a non-null status using entity framework, and show the azure functions: queue writer and database population.

Learn how an http-triggered Azure function writes to a queue and creates an Azure SQL database with a server, configure firewall for Azure services, and store the connection string.

Build an end-to-end Azure function flow that handles an HTTP trigger writing to a storage queue, uploads and resizes blob images, and updates the SQL database record status to completed.

Configure a blob service client in a .NET web project to upload files to Azure blob storage. Retrieve the storage connection string from app settings and use the Azure.Storage.Blobs package.

Inject a read-only blob service client via dependency injection, retrieve the target container, create a blob client for the file, set content-type headers, and upload via upload async.

Demonstrates uploading an image to blob storage, resolving port issues, reviewing logs and database entries, and planning an Azure function trigger to resize the image into another blob.

Create a blob-triggered Azure function that resizes uploaded images to 100x100 using six labels image sharp, and saves the output to a separate blob container via blob output.

Trigger a blob upload to run multiple Azure Functions, resize the image, and update the database status by extracting the ID and marking the request as completed.

Create an azure function with a blob trigger for the final resized image to update the sales request status to completed in the database, using entity framework and dependency injection.

Set up a timer trigger in an Azure function to run at intervals, using a cron expression to schedule every five minutes and update image processed to completed.

Learn to implement an Azure function timer trigger that runs every five minutes, retrieves sales requests with status image processed, and updates them to completed.

This lecture shows how to build a restful api with an Azure function, implementing get and post endpoints for a grocery item via an http trigger under grocery list.

Invoke the grocery api endpoints from the Azure function, fix the database context to grocery items, then observe the endpoint returning an empty list until records exist.

Implement and test get and post endpoints in a .NET web project using a grocery controller, model, and views. Wire the http client to the azure function and validate routes.

Explore all grocery endpoints, including create, get by id, update, and delete, with request id handling, item retrieval, deserialization, and saving changes to the database.

See how CRUD operations come to life in an Azure Function API connected to a database, with live grocery updates, edits, and deletes demonstrated and tested.

Publish an Azure function from Visual Studio to a new function app, configure the Azure SQL connection string and environment variables, enable Application Insights, and validate HTTP and timer triggers.

Deploy and test an Azure function, manage function and master keys, and wire up grocery endpoints with proper authorization to run create, get, edit, and delete operations.

Explore Azure Logic Apps cloud-based integration with a visual drag-and-drop designer and 200+ pre-built connectors, no coding required. Create event-driven workflows, monitor performance, and scale automatically in a serverless environment.

Navigate to portal.azure.com to create your first logic app using the consumption model, with an http request trigger in East US, noting the 4000 free actions and no log analytics.

Master building a logic app with a drag-and-drop designer, configuring an http trigger, generating a URL, and returning a 200 hello response while exploring actions, connectors, and run history.

Create a dotnet ten mvc project to upload data and capture it in the next Logic App, placing it in an Azure Logic App example folder named Azure Spooky Logic.

Create a new spooky request model in the logic app with required name, email, and phone, reuse the function's index view, set startup project to logic app.

Replicate the previous web app flow by posting uploads to a logic app instead of an Azure function, wiring in blob storage, dependency injection, and http headers.

Configure an azure logic app to receive an http post from a web app, insert the payload into an sql table named spooky_request, and enable json conversion and endpoint setup.

Learn to create a SQL record on HTTP post by using a logic app to insert a row into SQL server from an HTTP request payload (name, email, phone number).

Learn to send emails from a Logic App using SendGrid by creating an API key, configuring the connection, and wiring in row data (id, name, email) to the message.

Copy a blob from the logic app folder to processed folder using a blob trigger in Logic Apps. Configure containers and connections, and note the consumption plan and run history.

Coordinate the complete logic app flow for blob storage uploads. Classify images and non-images, route to final folders, and sync to Dropbox.

The lecture shows configuring a logic app to copy a blob to dropbox by retrieving blob content and creating a file in a folder named Azure Fundamentals.

Implement an if-else in a Logic Apps workflow to classify blobs as images using an or condition on extensions, and copy them to images or non-images folders with parallel execution.

Configure a logic app to copy blobs, categorize images into an images folder, and route non-images by media type—pdf, zip, or other—into dedicated folders.

Learn how to use Azure Redis Cache in a dotnet application to store frequently requested data in memory as key-value pairs, reducing database calls and boosting performance.

Harness Azure Redis Cache to achieve super-fast in-memory data storage and retrieval, managed by Microsoft, with disaster recovery via geo replication.

Create an Azure cache for Redis in the portal, selecting subscription, resource group, location, and the basic C0 250 mb option with version 6, then deploy and access the resource.

Create a dotnet core mvc app named Redis Cache, add a category model and dbset, run EF Core migrations for Azure Redis Cache, and update the database in SQL Server.

Scaffold a category controller with Entity Framework Core, enabling CRUD operations and views, configure the DbContext, run with Redis cache, and create several categories before Azure cache.

add azure redis cache to a dotnet core app by copying the connection string, installing the distributed cache package, and configuring program.cs to use the Azure Redis connection.

Implement caching for the home page index action by retrieving categories from the database via the application db context and storing them in the Azure Redis cache for subsequent requests.

Implement caching with a distributed Redis cache via dependency injection, using a category list key and JSON serialize and deserialize to store and retrieve data.

Explore configuring Azure Redis cache in a dotnet app, using distributed cache entry options to set absolute and sliding expirations, and invalidating the cache to refresh data from the database.