Complete Microsoft Azure Developer Associate (AZ-204) Study Guide

hey this is andrew brown your cloud instructor exam pro bringing you another complete study course and this time it's

the microsoft azure developer associate also known as the az204 made available to you on freecodecamp this course is

designed to help you pass and achieve microsoft issued certification and the way we're going to do that is by doing

lecture content follow alongs a practice exam and have cheat sheets for the day of the exam so you can prove on your

resume your linkedin you have that as your knowledge you can go get that cloud job or get that promotion and tell you a

bit about me i was previously the cto of multiple ed tech companies 15 years industry experience five years

specializing in cloud i'm a nativist community hero and i've published many many free courses just like this one i

love star trek and coconut water and i just want to take a moment here to thank viewers like you because it's you

that make these courses possible and the best way to support more courses just like this one is to purchase the

additional study materials at az204 so you can get access to study notes flash cards quizlets downloadable lecture

slides downloadable cheat sheets practice exams ask questions get learning support but if you sign up

right now for free you'll get a practice exam and cheat sheet there's no credit card required the free stuff does not

have a trial limit so you do not have to worry about it vanishing it's not a demo uh if you have if there are updates to

this course they'll be in the youtube descriptions on free code camp so watch out if there are corrections additions

modifications to make sure you're using the latest version of this course and if you want to keep up to date on upcoming

courses the best way to find that is on twitter i'm at andrew brown on twitter and if you do pass i love to hear uh you

know your success story um or what you'd like to see next so there you go hey this is andrew brown from exam pro

and we're at the start of our journey asking the most important questions first which is what is the azure

developer associate so it's a microsoft certification about the azure platform focused on multiple ways to deploy web

apps to azure a deep dive into azure functions i mean seriously deep a broad look into application integration

services which azure has a lot of to the point where they have ones that cover the same purpose and lots of

hands-on with azure cli sdks or programmatic interactions with azure services so anything to do with the

azure api the course code for the azure developer is the ac204 not to be confused with the 104 but it is very

complementary to the other course which we'll talk about when we talk about the roadmap and i do want to point out that

microsoft azure is a very code and script driven uh platform compared to aws and gcp so it's better having

developer knowledge and i actually consider it a must when we're working with microsoft and i'll explain why here

in a bit so who's the certification for we'll consider the 204 if you are a web app developer looking to pick up cloud

skills or transition to a cloud developer role you are a cloud developer cloud engineer who needs to integrate

azure services into your app or deploy your app to azure or you need to learn a lot about azure functions to build

service workloads but as a note i kind of feel that this is an essential certification at the associate level and

so looking at a roadmap i always suggest people to start with the az900 which is the fundamentals because it's going to

really help you get not just introduced to azure but also the test taking

experience because it is a much difficult and different experience than the other two providers

and generally from that we usually recommend to go with the administrator the 104 because that is a broad amount

of services and that is the most common use case why people are on microsoft azure because they're usually i.t dev

shops but as a complimentary usually after that i would recommend to go to the

developer the az204 because the nature of azure is that a lot of the ui it like is script driven so when you are in the

portal uh you have to touch script more often than not or you might run into features that simply do not exist in the

portal so you have to use scripting so really to be a proficient pers person working on azure you need developer

programming experience and so i always pair these two together now where you want to go after that is up to you a lot

of people like to go the solutions architect or the devops engineer expert there's a bunch of other

associates and i consider these kind of like uh like mid-level specialties where you can do those there's of course more

certifications than we're looking at that is actually here but you know these are the most general

ones here so you know hopefully that gives you an idea that you should probably take the developer after your

associate and then after that you go wherever you want in terms of difficulty the azure

developer associate is i would say two times harder than the aws developer associate and three times more difficult

than the gcp associate and i'm talking about the exams not necessarily the application

of being a developer in the platform but just the fact that the way azure makes their exams is they really want to test

for practical knowledge so it's not about conceptual or strategic information not to say that there isn't

those kind of questions on exam but it's a huge focus on do you know how to actually set things up and do you know

the nuances of them so you're going to see a lot more labs than normal in my courses for this particular study course

how long does it take to pass well it depends on you but to give you a general idea if you're a beginner so let's say

you had the az 900 but not much hands-on experience you've never written code or attack role then you're looking 50 hours

even if you've taken the easy to 104 it's still going to take this long because it's a different uh different

beast than the 104. if you're experienced so you already have practical knowledge working on azure uh

you've deployed apps to azure you have a strong background in programming you're looking at 20 hours and so i like to uh

set a goal of somewhere in between so 30 hours average study time so for lectures in lab that's going to uh take up 50 of

your time so you know we're looking at it's probably more uh labs and lecture and then the other part of it is 50

practice exams so i recommend you study one to two hours for 20 days and really do spread that out because if you do too

much of it together uh you have a a good chance of forgetting information so you know make

sure you spread that out and make sure that it's it becomes part of your long-term memory so where do you take

the example you can do it in person or test center or online from the convenience of your own home so

microsoft delivers exams via two different uh providers psi online pearson vue and those are online proctor

exam systems both of these providers have their own test center networks so whether you want the online experience

or in person it's just to be up to you i strongly recommend if you can to go in person it's less stressful if you have

the opportunity if you can't you have to do your home it's up to you which one you want to choose they're more or less

the same i like pearson vue but some people like psi so

it just depends if you take a couple you'll decide which one you like and if you're wondering what the word proctor

means it means there's a supervisor somebody is monitoring you as you taste taste uh take the exam to make sure

you're not cheating that's the whole idea behind it to make sure these are legitimate uh scores so what does it

take to pass example you're going to have to watch video lecture memorize key information you have to do hands-on labs

and follow along within your own account you i would recommend paid exams to simulate the real exam i'm going to help

you out by giving your first exam for free no credit card required just sign up on exam pro and um you know you can

go get access to that and other free additional content that i strongly recommend that you do

for the content outline we got five domains each domain has its own weighting that determines how many

questions in a domain will show up and azure is interesting because they do a range of questions so it's not a

guaranteed of a certain amount of questions on exam it's going to be between ranges so the first developer or

sorry develop azure compute solutions develop azure storage implement azure security monitor troubleshoot and

optimize azure solutions connect and consume to azure services and third-party services in terms of the

grading you've got to get about 70 percent to pass and they use scaled scoring so

uh you know it's not always exactly on the dot but you for the most part if you get 70 percent you should pass in terms

of um amount of questions is between 40 to 60 you probably see 55 questions so you can afford to get about 12 to 18

wrong some questions are worth more than one point there's no penalty for wrong questions some questions cannot be

skipped and for the formatted question you've got multiple choice multiple answer drag and drop hot area case

studies all sorts of kinds of questions that you'll encounter much more difficult than the az 900 for sure

in terms of the duration you get three hours so that's about one minute per question but of course different

question formats are going to be different uh you have 180 minutes for the exam time your seat time is 210. so

you have about um 30 minutes um in terms of the whole time that you said schedule so even if you have 180 minutes you have

to consider the entire time to get logged in and all that other stuff so time to review instructions reading

accept the nda complete the exam provide feedback at the end and i'm telling you if you're taking this online

show up early because so often you're fiddling around with your license to try to get to scan properly and then they

don't like it so you have to scan it twice so you know if you can show up an hour early and make sure you block that

time this exam is valid for i believe two years before recertification so you know

there you go [Music] hey this is andrew brown from exam pro

and before we dive into azure functions we need to understand what is serverless so serverless architecture generally

describes fully managed cloud services and i say generally because um you know that definition of serverless can be

highly contested about what can be serverless and what can not be serverless so it's not a boolean answer

of yes or no but some services are more uh serverless than others to a degree and so you know the way to help you

understand serverless is the way i define it is i look at the following characteristics one thing for a

cloud service to be serverless is that it should be highly elastic and scalable highly available highly durable and

secure by default another thing is that it abstracts away the underlying infrastructure and are built based on

the execution of your business task so you're not really worried about how many cpus and things like that maybe they are

abstracted into like virtual cpus or away from what the original

hardware software is using the idea is that it's a simpler value then the idea is that serverless can scale to zero

meaning that when it's not in use you're not paying for anything and the most important thing is you're paying for

value so you do not pay for idle servers and just to kind of reinforce that idea that um

that uh it's a degree uh my friend daniel who's really big in the service loves to describe it as like the energy

rating system so the idea is that uh when you go to buy an appliance such as um you know a washer or dryer they'll

tell you how energy efficient it is and that's kind of the idea behind serverless services and uh you know

we're going to be talking about function as a service but function of service does not necessarily guarantee that it's

a serverless service but we'll talk about that in the next slide okay [Music]

all right let's talk about function as a service also known as fast so here's kind of a diagram that i like to use to

visualize it but we'll get to it in a moment here so what is function as a service it allows developers to focus on

just writing pieces of codes also known as functions and it has event driven integration trigger functions based on

event data or to emit event data so it's not just a matter of having a piece of function or code that you write in a box

but the fact that it has to be event driven generally multiple functions are

orchestrated together to create a serverless application sometimes also known as microservices functions

generally only only run when needed and so function as a service is not serverless on its own

so fast function as a service it's only serverless if it's fully managed and it scales to

zero just to take a closer look at this graphic here so the idea is that if we're talking about the underlying

infrastructure it's of course running on some kind of physical server and from there you'll have a host

operating system and then you it could be a hypervisor and then from there you could have a

virtual machine running a container runtime like the docker daemon um or you know it could be

there are some os's that are optimized to run a container runtime without a hypervisor

but the important part is the idea is that you're just deploying these little pieces of functions and they generally

will go into a container so you might have a container runtime

that is specifically configured for ruby or it might be configured for java or python or net and then the idea is

that you're dropping that code and that code's getting scheduled into that container

but hopefully that gives you kind of the general idea of what function as a service is

[Music] hey this is andrew brown from exam pro and we are taking a look at azure

functions and this is a function as a service fast offering that allows developers to focus on writing code and

not worry about maintaining the underlying computing infrastructure and so here is our

visualization so we can kind of break down the anatomy of how azure functions work so the first thing you'll need is

an function app and this defines the underlying compute for a collection of functions so a function act defines the

hosting runtime and global configurations then you have the functions themselves these represent

code along with application runtime configuration so the idea is you can say i want this to be a python function a

net function etc etc there's always going to be a trigger so a trigger is the chosen event

data that will cause the function to execute and you can only have one trigger

you have input bindings these are one or more multiple data sources that will be passed to the function when a trigger

occurs so the idea is you can pull in data from a variety of different azure services at the time of trigger which is

uh quite nice and then you have the output bindings these are one or more data syncs that

will receive outputted data from the function on successful execution they say syncs you could say consumers if you

like and also azure functions at least as of today has four different versions you

really do want to just use the latest version there could be a version 5 out by now i

don't know but you know just be aware that you're always using the latest version but

in practicality you probably won't be able to tell the difference between the versions but just make sure you're using

the latest okay [Music] all right let's take a look at storage

considerations for azure functions because every function app requires a storage account to operate and if that

account is deleted your functions are just not going to work so kind of a small visualization of your function app

linked to a storage account so azure functions uses the following storage types in the storage account it's going

to vary based on use case so for blob storage it maintains binding state and function keys for azure files file share

used to store and run function app code in a consumption plan premium plan as your files is set up by default but you

can create an app without azure files under certain conditions for cue storage this is used by task tubs in durable

functions we have a little section on durable functions and then for table storage used by task hubs and durable

functions as well so there you go [Music] okay let's take a look here at the

anatomy of a single azure function so here is a screenshot of visual studio code because this is where you're going

to be writing your functions you can write them somewhere else i sure don't know where but

they have really strong integrations with visual studio code but the idea here is that we have a

visual studio code plug-in installed that allows us to manage our remote functions and we have

local projects but let's take a look at some of the files that are in here so we can understand what kind of files matter

to our functions the first is functions.json this is configuration of a single function defining bindings and

we talk a lot about bindings uh in the azure functions section of this course there's the code itself in this case

it's a javascript file we have the func ignore that's just like a git ignore file but it's to ignore files like files

to be not packaged right so like when it actually deploys the function you don't want those files included but

you might use them in local development we have host.json this is global configuration of all functions at the

function app level then there's the local project itself this is just where the function is

stored locally and a lot of times you're moving that code to uh to the remote storage on azure and if we were just to

open that up you can kind of see the same files being mirrored so we have the name of the folder so host json function

json index etc local settings json package json things like that

so i'll just kind of erase a little bit of this out of here but you get the idea and it'll make a lot more sense when we

start making functions which we absolutely do in this course critical for the az204 so

but we'll do that soon [Music]

all right let's take a look at authorization levels this determines what key if any needs to be present when

making a request when a function is getting invoked and the authorization levels can be one of the following we

have nominus function and admin so anonymous means that anybody can invoke the function so if it's an

https request in order to trigger it anybody can trigger it

for function you'll need a specified api key this is the default value when you're creating your functions generally

recommended as the means to use or you can have it so that it has to use a main key

to be required yes it's called master key i'm just going to use the word binky and for integration if you're trying to

figure out how to change the authorization levels after you've deployed a function you're just

going to click on your https trigger and from there you can switch the authorization level now that's not

always the case there's some cases where you're not able to change it via the portal

um and that just has to do with you know the type of runtime you're running whether it's a custom run time

but yeah that's where you're going to do it there and you can change it after the fact after creation okay

[Music] let's talk about how we would debug our azure function well you have this

ability to turn on uh streaming logs and this allows you to see near real-time logging when errors occur and it's not

as simple as that because there are two options for streaming a file log the first is built-in logging stream

and so the idea is that you have the app service platform lets you view a stream of your application log files and then

there's live metrics stream so when your function app is connected to application insights you can view log data and other

metrics in near real time in the azure portal using live metrics stream and log streams can be viewed both in the portal

and in most cases the local developer environments such as visual studio code now when i

was doing this i was trying to turn it on and i did not get any logs in near real time but i think the reason why was

because the hosting that i had it backed on wasn't on app service platform so i think it really does matter where you

host it um and so you know maybe we'll explore that in the follow along to see if we can see your real-time logs

but yeah there you go [Music] all right let's take a look at the key

concepts for azure functions these are not exactly my words but i will uh provide exceptions here as we describe

this stuff but the idea here is that we want to get broader knowledge about azure functions so azure functions are

lightweight and can be serverless and they can be and this is only going to be dependent on how you host them and we'll

talk about that in a moment azure functions are easier to write and deploy usually write deploy than

full web applications uh that can be true the idea though is that you are uh you might have to

do less coding in some regards but then you might have to do more in other places

like application integration so i would say that it shifts the responsibilities of what you have to

work on but you it is better i think azure functions are fast execute because there is no at large application startup

time initialization or other events fired before the code is executed now true that large applications there are

those downsides to them but the the trade-off here is that if you're using serverless functions then you will be

dealing with cold starts um and so cold starts just means that uh you know

when you're when you have a function that hasn't been used in a while that's going to have to boot up an environment

so you know there is that trade-off now in many cases you can

pre-warm or have continuously running compute but if you do that then you're not

necessarily leveraging serverless like to be able to scale to zero but you know you do get trade-offs azure functions

execution is triggered when an event is fired that is true azure functions do not need any infrastructure and it has

zero maintenance well they do have infrastructure it's just that you don't generally have to worry about the

infrastructure in terms of azure's implementation of functions you do have to think a little

bit more in general about the infrastructure underneath as opposed to google cloud or aws but at least you

have a lot of options on azure and it has zero maintenance well the infrastructure that's true but um

the your code itself you know if you're using python 2 and microsoft says hey we're going to expire or uh deprecate

the python 2 runtime you have to use python 3 well then you're going to have to

upgrade that stuff so that is your maintenance so there is management code but

that's no different than any other provider azure functions can be built tested deployed in the azure portal

using a browser only if you're using windows so uh if you are hosting on linux there are definitely

lots of limitations in the azure portal if you're using windows then there's no problem in most cases

you should just use windows because you're not going to be able to tell the difference

in most cases but if you want to take the full advantage of being able to work in the

portal absolutely use windows azure functions are easy to upgrade and doesn't affect

other parts of the website again this is subjective based on uh the code that you have to upgrade right so

or functionality that they change so you know generally it's true it can be easier in isolate to update parts of

your application because they're all little functions but there are exceptions to that azure functions use

industry standard protocols probably https here and communicate with other apis databases and libraries that's true

you only pay while your functions are running that is true if you use the serverless model if you're continuously

running virtual machines behind the scenes then you are going to be paying all the time azure functions

automatically scale to meet the demand of traffic that is true underneath azure will provision more service containers

that is true azure function scale scale to zero cost can depend on your hosting azure function has built-in

monitoring via azure monitor which it absolutely does and it can integrate or has built-in ci cd via azure devops

which is very nice azure functions are event driven and will be triggered based on event data and emit event data

absolutely and if they didn't then it wouldn't be functioned as a service but there you go

[Music] all right let's take a look here at use cases both business and technical for

azure functions so for business use cases you can use them for scheduled tasks reminders and notifications

lightweight web apis sending background emails running background backup tasks doing back-end calculations there are

technical use cases such as sending emails starting uh starting a backup ordering processing

task scheduling database cleanup send notifications messages iot data processing so azure functions are best

suited for smaller apps that have events that can work independently of other websites originally i had some text in

here that said like azure functions were not suited for large applications but more of these menial

jobs around a larger application which is not true you can build a whole application out of functions

now whether that's easy to do with azure functions is another story because it has to do with cold starts and things

like that but i i definitely think you can but this is just kind of give you creative ideas of

how you can use azure functions outside of the normal use case of just building a web application so there you go

[Music] all right let's take a look at vs code extension because this is going to be

the primary way that you are going to be working with azure functions so in order to productively work with azure

functions you'll need the visual studio code azure functions extension and so what

you'll do there is install that once it's installed and you have an azure icon

in your activity bar with the side bar drawer you can look for functions i'm going to get my pen tool out here so the

idea is you install this and then now you have at the top here the functions

tab so you can manage azure functions it's possible to use azure portal to create and update windows host hosted

azure functions but in practice it's not an easy experience with linux it's impossible

this is a very kind of different experience compared to something like aws or google cloud where you can do

basically everything in the cloud but with azure functions you really

really really rely on visual studio code you can use visual studio for net and c-sharp app functions i've never done it

myself but it is an option out there so there you go [Music]

let's talk about runtime so what is an application runtime an application runtime is a compute environment

configured with the necessary software and system configuration to run a specific type of application code so

here uh if we were to create an azure function we have some options and you

can see runtime stack so azure provides multiple applications and runtimes for popular programming languages just going

to highlight that out there because i don't see my my arrow but uh it has things for uh net

so that's c sharp java node.js that's both javascript typescript powershell core python there's my uh

there's my nice arrow there um unfortunately does not have ruby at the time of recording this i really would

like them to have it but if you want something that's not there what you can do is implement your own custom handler

i believe they have an example either for rust or go in the documentation or let's say you want to do ruby

that is something that's on the 204 exam but in practice it's really really really hard to get a working custom

handler and i say that by i tried to make a ruby one it didn't work i tried their tutorial it didn't

work i reached out to the person that wrote the tutorial they couldn't get to work i went to support they couldn't get

it to work so in theory custom handler sounds great if you can figure it out um so you know if there isn't a custom

handler uh follow along you'll know why um but uh yeah that is an option on the table the runtimes provided by microsoft

are just docker containers you can see them on the docker hub um and you know a lot of times you know containers and

functions are strongly related because they're generally almost always running on

containers okay [Music] all right let's take a look at windows

versus linux hosting so when you create an azure function app you can choose either windows or linux as your host and

this actually it makes a big difference based on the capabilities that are available to you

and we're talking about things where there could be performance differences functionality limitations feature

differences but generally you know when we're using microsoft it's always good to attempt to use windows when possible

because their whole ecosystem is built around windows and not so much linux one example here

is that if you are using a linux hosting for azure function apps you cannot edit the function after it's

been deployed and that is a very major inconvenience so just consider that when deploying functions i usually can't

tell much the difference between linux and windows so i'll just choose windows so i

get that additional functionality if you need to determine the exact os that is being used what you can do is go to

docker hub repository because again all these uh all these images or

runtimes are stored on docker hub and there we can see the windows images and the linux images

and notice for linux there is a lot more variation where windows is just the nano server 1809 so that's the windows server

1809 whereas linux there's a little bit more options and mostly debian but you do have one down here that's ubuntu but

there you go [Music] all right let's take a look at templates

for azure functions so azure provides function templates to get you started with common functionality scenarios this

is going to happen when you first create your function now you don't have to use one but definitely this is the route

that you should want to go especially if you're choosing http trigger which is very common so

to choose the template you're going to be doing that in visual studio code so you don't do it in the portal but let's

just kind of walk through the templates we have available so we have http so triggered by http request and returns an

http request you have a timer so triggered based on a schedule blob storage triggered when files are

uploaded updated in a blob storage container cosmos db triggered when processing a

new modified cosmodb document cue storage triggered by azure storage queue messages

event grid so triggered by event from event grid so many azure services can be triggered

as a function through event grid okay as we cover event grid in this course

a lot of sources can be ingested into event grid event grid is serverless event bus integrated with azure service

as we do cover at other parts intercourse uh event hub so triggered by an event hub event so

this is for streaming service bus queues are triggered by a bus queue this is messaging service bus topics the

triggered by uh an event from a bus topic so this is a pub sub model then you have send grid so triggered by an

email event in a third party service center if you ever send grid it's just for sending out emails

and so there's a lot there does it set up the bindings for you probably i never really noticed or checked but i would

think that if you were to set one up for blob storage you would get the binding set up for you in your

function json but we will look actually next at function json

configuration because that is what is next in the course [Music]

so for every single function there is a function configuration file called function json and so there's the

structure there it defines the functions triggers bindings and other configuration settings when you choose a

template you're going to get some default stuff there let's talk about three main things under bindings so you

have the type of binding which is just the name of the binding which will affect the other attributes

that are underneath often that you'll have a direction like in and out uh and then there's the name and the name is

going to vary so for c sharp it's an argument name for javascript it's the key valued list but it's what is used to

bound data in the function and we will definitely cover a lot about bindings because bindings is super

important but just so you know function configuration file again is for trigger

bindings and other configuration settings [Music]

another file that you'll find in your function is a hosts dot json and uh this is for configuring global configuration

options for all functions within the function app here is an example one uh so

as extension for http you can see it has a rope prefix things like that it's setting a custom header and there is a

lot of stuff you can configure here for options so we can do aggregators application insights blob console

cosmodb extensions and then you know http cues retry send grid a whole host of things

and you know not super important for the exam but definitely in practice you will be

going this fall uh and configuring things need be but there you go [Music]

let's take a look at plan services for azure functions and we have three to choose from consumption function premium

and app service plan very different very interesting uh options for you to decide where you want

your compute to run and how your compute to run for functions you do not see a bus or google cloud doing that but the

flexibility here is very interesting so the first is consumption plan and this would be considered serverless and

because it's serverless it can scale to zero and because it can scale to zero that means that uh

generally we will have cold starts so you only pay for the time your code or application is running billing is based

on the number of executions and the duration of each execution and the amount of memory used just pay while you

have functions running and scale it automatically even through long loading times then you have premium

plan these are functions premium this is where we have pre-warmed uh pre-warmed compute underneath so the user has

designated a set of pre-warmed cases which are already online and ready to react instantly azure provides any

additional computing services that are required when your function is running you pay for the constantly pre-warmed

instances including any additional instances needed to scale the azure app in and out azure functions host

instances are added and removed based on the number of incoming events so um you know the idea there is that

you're not waiting for the container runtime to spin up it's already running but it's not going to scale to zero

and you know i mean you can still say that it's serverless in some regard i would consider that now being a fully

managed service but not necessarily serverless but you know that's debatable the last

here we have dedicated plan this is with app service plan and this is where we're doing vm sharing and this one is

extremely unique uh you do not see this in any other cloud provider but this is where when you use app service

for other apps your functions will run on the same plan virtual machine at no extra cost you may scale it out manually

by adding more virtual machine instances for an app service plan you may also have

auto scale enabled optional when you have existing underutilized virtual machines which also operate other

instances of the app service so i think what happened was um

people were using apps app service right platform as a service and they just had un under they weren't utilizing all of

the virtual machine compute and so a customer must have said hey can i just

take my functions and utilize or utilize the unutilized compute on my plan and that's azure's

like sure and they made that a thing so it's just like an interesting way to

save money but it is one of those things where it is a little bit hard to understand because it's not uh as

isolate or modular in terms of functionality where we see other cloud service providers but those are your

three plans so there you go all right let's take a look at triggers and bindings for azure functions we

talked about them before but let's give them a little bit more attention so triggers and bindings let you avoid

hard-coding access to other services and abstracting away boilerplate code keeping your functions lean

because the idea is that you won't have to add that code into your functions so

here is our graphic which represents a function we have input bindings output bindings we have a trigger there so what

is a trigger a trigger is a specific type of event which causes the function to run

it defines how a function is invoked and a function must only have one trigger uh triggers can have associated data which

is often provided as the payload of the function and you know as we saw in the introduction that we can have multiple

sources of inputs that that get added there in this example here we have http but we're bringing in data from

blob storage as well and obviously the main trigger uh which http is an input as well so you can have

additional inputs at the same time then we'll take a look here is what is a binding

um and so my arrow's a little bit messed up but the idea is binding is defined if your

function is connected to another service so we have input bindings and output bindings

so the data from bindings is provided to functions as parameters bindings are optional and a function can have

multiple input and output bindings optional but often used which we'll find out but let's take a

look at what supported bindings are in the next video [Music]

all right now let's take a look at what supported bindings are available for azure functions there's quite a few here

and we'll quickly go through them just so you have a scope of idea so we have blob storage azure cosmos db

um or cosmodb i always want to add that s in there azure sql dapper which is a

run time we cover it in the course it's a runtime for distributed applications for

microservices event grid event hub uh http web hook that's gonna be the most common one you'll use iot hub kafka

mobile apps notification hub that's for push notifications queue storage messaging rabbitmq that is an open

source um viewing system sendgrid which is for sending emails service bus which is both

queuing and pub sub signal r which we don't really talk about much in this course but it's an open source.net

library to send asynchronous notifications to client-side web applications table storage timer uh

twilio all right and so what's also important to note and sorry i could not make this graphic better i really really

did try to present this better but it's just there's so many here but um the idea is

that some don't support triggers so like azure sql does not support triggers mobile apps notifications don't table

storage and twilio does not then you can see we have a big gap of inputs for a bunch here and a bunch there

it's not super important to know for the exam but the fact that that you don't get triggers inputs and

outputs across all services and there are some cases where the api version matters so like if you are using

version one some things are not going to be supported and even some cases version two like mobile apps notifications don't

have um uh don't have support so in some cases you do have to use uh version one

functions but most cases you'll be using version four so hopefully that gives you kind of

a broad idea of supported bindings but we're not done with bindings we'll be looking at more of it okay

[Music] let us talk about binding directions so all triggers and bindings have a

direction property in the function json file the direction of the triggers is always in and the input output binds

either is in and or out and some bindings support a special direction called in out

which a little bit confusing but it's nice to have a extra option this idea is we have a direction and triggers again

are always in and then you have in out and in and out um the trigger is defined alongside the

input and output binding so trigger will have the same as the input type but with trigger appended so for example if we

have blob that would be our input binding then we'd have blob trigger as the trigger and that's how you would

know the difference right so again just iterating see where it says uh a type here if it was just http

then it would just be a a binding but if it's a http trigger then it's a trigger with a with also an

in binding if you use the in and out only the advanced editor is available

via the integrate tab in the portal just so you know because there's a visualization of integrations that we

see in the azure portal and so they're talking about that in and out option there okay

[Music] okay so now what i want to do is just go through a few scenarios of triggers and

bindings to help cement the idea of their utility so we'll take a look at our first scenario so every hour you

want to read a new log file delivered by your application and you'll need to transform the data to be ingested

in your nosql or sql database that resides in cosmodb so here is our visualization we have our

function which is python for fun it's going to output the cosmodb so we need a binding out to there

it has a trigger um here that's just triggered by an acp request to the timer and we got

the blob storage so you use a trigger timer i guess actually the http shouldn't even be

there i think that's just a mistake but you use a trigger type timer because it's a scheduled job that will run at a

specified time the trigger will be in for the blob storage and out for cosmodb because whenever function runs it'll be

on a timer and when it executes it'll read data from blob storage process the data from blob storage and then write

some data in cosmo db so the key thing here is that this runs on a schedule you're not you're not

even though it's there you're not uh invoking it like with a an api request this is invoked on schedule let's take a

look at scenario two every time someone signs up to your application you want to trigger an email so here there is an

http request coming in and it's going to send out to sendgrid to send out that email so you want to develop an api that

allows you to send an email after request is received and you'll use http trigger because it's

an api that will be triggered based on this request for the bindings you uh you won't be accessing any data well the

function starts so the in direction is none and you'll be uh you'll use send grid

for the out direction which allows you to send messages via email looking at our third scenario consider a scenario

in which you're using a cue service and you want a function to process a storage message in one queue and enter a new

message in another so the idea is you have a queue again it's fun it's triggering something and it's going to

output to something so in this case you'll want to use um into it says consider uh scenario q

service where you want to function the storage message in one queue and enter in another so probably

this this icon's old but we probably should have this icon repeated twice because this is the sendgrid logo so

just imagine that we have we took this icon and we put it over here very sorry for that uh graphical error but um the

idea here in this case you want a trigger type of queue and a binding type of cue for the direction out because

you're not accessing the queue in the in direction you read the data from one queue and process it to create a new

message and then to write to a different queue which may or may not be connected to another service or function so there

you go [Music] all right let's take a look here at

bindingexpressions so in function json file and the function parameters code you can use binding expressions that

resolve to values from various sources so most expressions are identified by wrapping them in curly braces i say most

because there's an exception where you do not use curly braces but the idea is that

it allows you to have kind of dynamic content within your functioned json file and there are a variety of

different binding expressions we have app settings trigger file name trigger metadata json payloads

guid current date and time let's go take a look at what those look like the first is app settings so when

you want to change configuration based on the environment you're going to use percentage science this is the only case

where you use percentage signs uh it's confusing because it's the first example instead of curly so notice that

there's curly sorry percentage signs there um

and then for trigger file name this can be used to change the path of a file name works for both in and out

directions so here we have the curly's here to say for the file name

for trigger metadata many triggers provide additional metadata values these values can be used as input parameters

for c sharp f sharp or properties for context bindings and objects in javascript so for example if we're doing

azure queue storage sugar supports the following properties q trigger dq id etc etc

uh and then you'll notice that they are available here's the cq trigger is here q trigger

that's typed in camel case mode for json payloads when a trigger payload is json that means the the the data

being passes json you can refer to its properties and configuration of other bindings and the same function in the

code so you know if the payload was blob name and then hello helloworld.txt

do blob name and that would put that here okay um and

if some of your properties and your json payloads are objects you can use the dot notation so that's just a common

thing for json or yeah json or javascript um for for if you want a globally unique identifier

you can just do rand guid and you'll get something that looks like that if you want to have the current date and time

you do date time you're going to get the current date and time in this format so there you go

[Music] let's take a look at local settings file this is a file we saw uh when we were

looking at the anatomy of the local files and so the local settings file stores

app settings and settings used by your local development tools this file is called

local.settings.json is expected to be at the root of your project folder because the local settings json may contain

secrets such as connection strings you should never store this in a remote repository so make sure you add it to

your dot git ignore file here's an example of one so first we have is encrypted so when the setting is true

all values encrypted with the local machine key for values these are a collection of

application settings used when running a project so notice we have function worker runtime azure web storage uh or

job storage mybinding connections things like that the host customize the functions host

process when you run it locally and then connection strings used only by frameworks that typically get connected

strings from the connection strings area there okay okay so as your function core tools lets

you develop and test your functions on your local computer from your command prompt or terminal so it's a cli

uh and you type in func and allows you to do a whole host of things so let's take a look at the commands we have for

top level commands we have init so create a new function project in a specific language logs get the logs for

functions running in kubernetes cluster new creates a new function in the current project based on a template run

enables you to invoke functions directly which is similar to running a function using the test tab in the azure portal

start starts the local runtime host and loads the function project in the current folder deploy which was replaced

with function kubernetes deploy then we have command groups that contain their own set of sub

commands so we have func azure so this is when you're working with azure resources durable for

durable functions extensions for managing extensions if you're doing working with kubernetes

and azure functions you can do that if you are messing with settings that you do settings if it's with templates for

this available templates you can do that so there you go [Music]

all right let's talk about custom handlers these are lightweight web servers that receive events from

function hosts and they can be written as long as it supports http primitives and these are

really great in situations where you want to have a run time that is not supported for like a

language like go rust ruby uh or a runtime environment for a specific technology where you need a

bunch of libraries preloaded like ruby on rails or deno and so within your function

function json the idea here is you'll have a custom handler section and this is going to just basically define the

executional execution path because it basically is running a program custom handlers you can use

triggers and inputs and output bindings via the extension bundles

okay so let's kind of visualize that so we really understand that this is like a separate thing that's running

so the function will pass along the payload to the custom handler the communication between the function and

custom handler is via https requests and response the custom handler runs on white lightweight web servers

the underlying compute will likely vary based on what service plan is chosen so it's going to be other places i couldn't

really figure out where they were the custom executable for the custom handler is bundled along with your

function code so there's that there uh some some things about the application structure

to implement a custom handler your application must have the following a host json file a local settings json

file a function json file uh a command script or executable which will run on the web server

uh and then the following diagram shows how these files look on the file system for a function named myq and a custom

handler so here you can just kind of see it's not the prettiest but i mean it

gets the point across the idea is you have a folder here's your function json and this one happens to use an

executable in practice custom handlers are super super hard to do uh and i think i mentioned this before

but you know i was trying to set up a ruby one and it didn't work and i try to set up

the the tutorial one that's in the docs for rust or go that didn't work i reached out the person that made it that

didn't work i reset the azure support they didn't know how to do it so um if people running custom handlers if anyone

figures it out please tell me uh hopefully i do figure it out and we get included in this course if we don't just

understand if i couldn't do it then i don't it's not a big deal if you don't know how to do it okay but for me i

personally would have loved to run ruby because that's my favorite language to use

and that's what i would use on azure functions [Music]

okay so let's say you are making a custom handler you deploy it and you end up having an error that says runtime is

unreachable what do you do well not a whole lot but i can i can tell you that there are some things that you can

narrow down because a runtime could not be running for multiple reasons um so

uh you know the idea is that the runtime couldn't start and so there are some common reasons that azure suggests that

it could be so it could be storage account was deleted storage account application setting was deleted storage

account credentials are invalid storage account is accessible daily execution quota is full

app is behind a firewall so there are your possible reasons for things to go wrong uh i just wanted to share that you

know i ran into this and i i didn't necessarily get through it but i i wanted to share it to you possible

solutions okay [Music] hey this is andrew brown from exam pro

and we are taking a look at durable functions so durable functions is a serverless

compute extension of azure functions that allow you to write stateful functions the extension introduces two

types of functions so we have orchestrator functions this defines stateful workflows implicitly

representing state via control flow and entity function which manage the state of entity explicitly representing state

they define workflows in code so no json schema or designers are needed but honestly i would like one because other

providers like aws have like no code solutions so it's kind of weird they try to make it like sound like an advantage

but it isn't really an advantage they can call out functions synchronously and asynchronously uh the

output from uh from the called functions can be saved to local variables they automatically

checkpoint their progress whenever the function awaits local state is never lost if the process

if the process recycles or the vm reboots so durable functions currently support

the following languages so we have for c-sharp javascript python f-sharp

powershell and powershell seven to use durable functions you need to install a library specific to your language in the

root of your function app project such as npm install durable function so there you go

[Music] all right so if we are going to be having stateful functions we are going

to need a variety of different patterns for setting up

different kinds of serverless workloads let's take a look at them the first is function chaining so this is the pattern

of executing a sequence of functions in a specific order often the output of one function needs to be applied to the

input for another function durable functions allow us to implement this pattern concisely in code then you

have fan out fan in so this is this is a pattern of executing multiple functions in parallel and then waiting for them

all to finish fanning out can be completed with normal functions by having the function send multiple

messages to a queue fanning in is much more difficult because we have to write code to track when the q triggered

functions end and store function's output the durable function extension handles this pattern

with relatively simple code we have async http api so this pattern addresses the problem of coordinating

the state of long-running operations with external clients a common way to implement this pattern is to have an

http call trigger the long-running action then redirect the client to status endpoint then they can pull to

learn when operation when the operation is complete durable functions provide built-in apis that

simplify the code we write for interacting with long-running function executions the monitor pattern refers to

a flexible recurring process in a workflow such as polling until certain conditions are met a simple scenario

such as a periodic cleanup job can be addressed with a regular time trigger but it is interval but its interval is

fixed making managing instance lifetime difficult durable functions enables flexible recurrence intervals task

lifetime management and the ability to create multiple monitor process from a single orchestration a little bit more

here so we have human interaction so many automated processes involve some form of human interaction humans are not

always available and responsive as cloud services which makes invoking humans an automated process tricky so

automated process must must allow for this and they often do so by using timeouts and compensation logic

then we have aggregators so stateful entities this pattern is about aggregating event data over a period of

time into a single addressable entity the data being aggregated may come from multiple sources be delivered in batches

or may be scattered over long periods of time the aggregator may need to act on event data as it

arrives external clients may need to query the aggregator data so there you go

let us take a look at azure functions on kubernetes now i don't think this is on the exam but i just thought it was very

interesting a thing that azure functions can do uh and so i just kind of wanted to run quickly through it so you can

deploy any azure function app to a kubernetes cluster running on k running k-e-d-a if you don't know kita it is

kubernetes event-driven auto-scaling uh service and allows you to set up auto-scaling based on events from

various cloud native services and third-party services so in this case

it could be for azure azure function apps and so when we were looking at the core

uh core tools azure power tools whatever you want to call it um they had an opera they had the option to

deploy to uh kubernetes so i'm gonna assume that you'd probably be running an aks azure kubernetes service uh but

let's just read through some of the things here so kubernetes-based functions provide the functions runtime