Azure API Management (APIM) Part 2

Video Activity
Join over 3 million cybersecurity professionals advancing their career
Sign up with
Required fields are marked with an *
or

Already have an account? Sign In »

Time
14 hours 28 minutes
Difficulty
Intermediate
CEU/CPE
15
Video Transcription
00:00
>> Hello Cybrarians, welcome to Lesson 6.2
00:00
>> of Module 6 of this course titled
00:00
>> AZ-301: Microsoft Azure Architect Design.
00:00
>> Here are the learning objectives
00:00
>> that we'll be covering in this video.
00:00
>> We'll start by introducing you to the concept of
00:00
Revisions as it concerns APIM.
00:00
We'll then cover the concept of versions,
00:00
we'll try to explain the differences
00:00
between visions and versions,
00:00
so you know when to use which.
00:00
We'll talk about policies when it comes to APIM,
00:00
what policies can be used for
00:00
>> and the different options that are available to us.
00:00
>> Finally, we'll talk about
00:00
architectural decisions of APIM,
00:00
especially in relation to scalability,
00:00
use cases, availability, and pricing.
00:00
Let's get into this.
00:00
When our APIs are in production
00:00
>> and they're being used by developers,
00:00
>> we eventually need to make changes to those APIs.
00:00
It could be that we had in a new operation
00:00
>> that the backend service now supports,
00:00
>> or maybe we have a tab in a legacy operation
00:00
>> that's no longer supported.
00:00
>> Whatever the reason is
00:00
for having to make changes to our APIs,
00:00
it is best not to disrupt colors of our API
00:00
>> when making changes.
00:00
>> It's also useful to release changes
00:00
>> in a controlled way,
00:00
>> maybe even let developers
00:00
know about the changes we've made.
00:00
We can do this in Azure API Management
00:00
>> using something called Revisions.
00:00
>> This is how Revision works.
00:00
You can see on the screen
00:00
>> we have an existing revision of our API
00:00
>> that developers are using at the moment.
00:00
>> First, we had a new revision in the backend.
00:00
We make the changes that
00:00
>> we want to make to this new Revision,
00:00
>> maybe add in a new post operation,
00:00
we test the changes,
00:00
make sure everything is working fine.,
00:00
and when we're ready to go live,
00:00
we simply make a switch
00:00
>> and our revision that we created
00:00
>> we make it the current revision
00:00
>> and of course we can roll back if we need to.
00:00
It's important to note this,
00:00
which Revisions providers choose when to deploy
00:00
>> and when they want to go live.
00:00
>> Let's talk about versions.
00:00
With versions, there are times
00:00
when it is impractical to have
00:00
all the colors of our API
00:00
>> to use exactly the same version.
00:00
>> Maybe we have different tiers
00:00
that they're subscribing to.
00:00
Maybe there's a free tier
00:00
>> where we don't make all operations available
00:00
>> and maybe there's another tier
00:00
>> where people can pay for
00:00
>> and then we make more operations available,
00:00
>> if that could be the reason
00:00
>> or maybe we want our users
00:00
>> to have the flexibility to adopt
00:00
>> new releases of our APIs when they are ready.
00:00
We don't just want to force it on them.
00:00
This is where versions can help us.
00:00
With versions we can publish
00:00
multiple versions of our API at the same time.
00:00
This is how version works.
00:00
Again we have an existing version of
00:00
our API that developers are using at the moment.
00:00
What we do is we add a new version that supports
00:00
newer operations or maybe newer way to use our service,
00:00
we then publish this new version
00:00
>> as a new version of an existing API
00:00
>> within API management.
00:00
>> Then developers can opt in to start using
00:00
>> the new version when they're ready.
00:00
>> It is important to note the following
00:00
>> when it comes to differences
00:00
>> between visions and versions.
00:00
>> With revision, providers choose when to deploy,
00:00
when we go live and we only have one in production.
00:00
With versions, consumers choose
00:00
when to adopt so we can have multiple versions
00:00
in productions and then the consumers can choose
00:00
>> when they want to adopt a particular version.
00:00
>> Let's talk about APIM policies for a minute.
00:00
Policies are a powerful capability of APIM
00:00
>> that allows publisher to change the behavior of
00:00
>> the API true configuration without writing code.
00:00
There are two main types of policies.
00:00
There are inbound policies
00:00
>> that we can use to modify the request
00:00
>> that is coming from the client
00:00
>> before the request is sent to the backend service
00:00
>> and all of this happens within the gateway components
00:00
>> that we discussed in the previous lesson.
00:00
For example, we can set an inbound policy to
00:00
restrict incoming requests to specified IP addresses.
00:00
If a request is not coming from
00:00
one of the allowed IP addresses,
00:00
it's simply dropped by the gateway
00:00
>> or we can specify an inbound policy
00:00
>> to serve requests coming from the client,
00:00
>> we can add rate limits to them,
00:00
the amount of allowed calls within a time frame.
00:00
This can help to maybe protect
00:00
from things like DDoS attack,
00:00
distributed denial of service attacks,
00:00
by adding rate limit.
00:00
Then we have outbound policies
00:00
>> that we can use to modify responses
00:00
>> that are received from the backend service
00:00
>> and we can make modifications
00:00
>> before they're sent to the client.
00:00
>> For example, we can have
00:00
an outbound policy to hide setting
00:00
HTTP headers that are coming from
00:00
>> the responses from the backend service,
00:00
>> and we do not want these headers
00:00
to go to the requesting client.
00:00
So we can use outbound policies to hide these headers
00:00
or to delete these headers
00:00
>> and I'll be showing you in the demo.
00:00
>> Finally, let's talk about
00:00
some key architectural decisions of the APIM service.
00:00
Let's start by talking about use case first of all.
00:00
We earlier mentioned that
00:00
>> there are different pricing tiers of APIM
00:00
>> and they have different use cases.
00:00
>> For example, I'll be showing you
00:00
>> the demo using the developer tier,
00:00
>> which supports a lot of the features
00:00
>> and functionalities that premium tier supports,
00:00
>> but do not use this in production please.
00:00
It has no SLA support,
00:00
so it's for non-production use cases,
00:00
it's for development use cases
00:00
>> or for evaluation use cases.
00:00
>> Consumption use cases is mainly around scale.
00:00
Whenever we want maybe
00:00
>> even more flexibility in pricing, pay-per-use basis
00:00
>> and also in terms of we're not locked down
00:00
>> to the maximum amount of units.
00:00
>> We'll get to that in a minute.
00:00
Then we have the basic tier,
00:00
which is entry-level production use cases.
00:00
Standard, which is medium-volume
00:00
production use cases
00:00
>> and premium for high-volume
00:00
>> or enterprise production use cases.
00:00
>> Let's look at scalability.
00:00
When it comes to scalability you can see that
00:00
the more you move
00:00
to the right when it comes to the tier,
00:00
the more scale you have.
00:00
For example if you look at the cash
00:00
and this is talking about cash per unit.
00:00
Number 1, let's talk about units to begin with.
00:00
You can see that the developers here,
00:00
you can only have one unit,
00:00
so you can't really scale.
00:00
But you can see that basic,
00:00
you can have two units.
00:00
Standard, you can have up to four unit and premium,
00:00
you can have up to 10 units per region
00:00
>> and if you need more,
00:00
>> you could make a request to
00:00
Microsoft Support and they could increase that for you.
00:00
But you can see that the amount of cash
00:00
that's available per unit also varies.
00:00
Also, you can see the estimated maximum
00:00
>> throughput per unit varies depending on
00:00
>> the tier that you're using.
00:00
>> Finally, let's discuss pricing and SLA.
00:00
When it comes to pricing,
00:00
you can see that for the developer, basic, standard,
00:00
and premium we pay per hour and that's per unit.
00:00
When it comes to SLA,
00:00
you can see the SLA stable.
00:00
When it comes to pricing for consumption,
00:00
you can see that it's per call.
00:00
We are charged per call
00:00
>> and the first one million calls
00:00
>> that we make and that's free.
00:00
>> I hope that you've gotten
00:00
some useful information from
00:00
these lessons on API management.
00:00
Thanks very much for watching,
00:00
and I'll see you in the next lesson.
Up Next