WE'RE GOING TO GET STARTED. SO MY
NAME IS COLBY. I'M A PRODUCT MANAGER
ON THE AZURE FUNKS TEAM. AND I'M
GOING TO TELL YOU SIX THINGS YOU
NEED TO KNOW ABOUT SERVERLESS. IN
THIS TALK, I'M GOING COVER A BUNCH
OF DIFFERENT THINGS. A LOT APPLY
TO SERVERLESS IN GENERAL. BUT IN
GENERAL, THE IDEA THESE ARE SOME
TIPS AND TRICK, SOME GOTCHAS, SOME
THINGS YOU NEED TO KNOW. BECAUSE
THIS IS A 300-LEVEL SESSION, NOT
GOING TO DO TOO MUCH OF AN INTRODUCTION.
THIS ASSUMES A LITTLE BIT OF KNOWLEDGE.
BUT WE GET TO GO DEEPER AS A RESULT.
SO. COOL. SO THING NUMBER ONE WITHOUT
FURTHER ADIEU, USER LOCAL DEVELOPMENT
TOOLS. WITH AZURE FUNCTIONS, WE
SUPPORT A VARIETY OF DIFFERENT WAYS
TO DEVELOP YOUR APPLICATIONS. WE
ALLOW YOU TO CODE DIRECTLY IN THE
AZURE PORTAL BUT WE ADVISE THAT
TO HAVE THE MOST SUCCESS, WE THINK
YOU SHOULD USE THE LOCAL TOOLS.
FIRST AND FOREMOST IS VISUAL STUDIO
CODE. WE HAVE REALLY NICE INTEGRATION.
THERE'S AN EXTENSION AS THE AZURE
FUNCTIONS EXTENSION FOR VS CODE.
SUPER EASY TO INSTALL. FIND IT IN
THE VS EXTENSIONS LITTLE MARKETPLACE
THAT YOU HAVE IN THE LEFT TAB. IT'S
SUPER EASY TO INSTALL. AND FROM
THERE, DO ALL YOUR LOCAL DEVELOPMENT
AND OUTER LOOP AS WELL OF DEPLOYING
TO AZURE AND MANAGEMENT OF RESOURCES.
IN ADDITION TO THAT, WE HAVE VISUAL
STUDIO TOOLING AS WELL. SO FOR ALL
OF . NET DEVELOPERS OUT THERE, ANOTHER
SET OF TOOLS FOR AZURE FUNCTIONS
FOR VISUAL STUDIO. SIMILAR TO THE
VS CODE TOOL, LET'S YOU GET UP AND
RUNNING WITH FUNCTIONS, DEPLOY,
ET CETERA. AND LAST BUT NOT LEAST,
THE AZURE FUNCTIONS CORE TOOLS.
WITH THIS, IT'S A COPY OF THE FUNCTIONS
RUN TIME RUNNING UP IN AZURE LOCAL
ON THE MACHINE. SO THIS IS KIND
OF UTILIZED BY THE OTHER TWO, BUT
THE CORE IDEAS WITH THIS, A COMMAND
LINE EXPERIENCE THAT LET'S YOU USE
WHATEVER ID YOU WANT. SO WHATEVER
EXPERIENCE YOU WANT TO WRITE CODE
IN, WE SUPPORT IN AZURE FUNCTIONS.
ALL RIGHT, THING NUMBER TWO, THE
NEXT TWO OF MORE GOTCHA, PATTERNS
WE SEE. SO THE FIRST THING, PROCESS
IN BATCHES. SO BUILDING SERVERLESS
APPLICATION, THINK ABOUT THE OTHER
GREAT PROGRAMMING PRACTICES THAT
YOU HAVE LEARNED OVER THE YEARS.
YOU CAN'T JUST KIND OF ASSUME THAT
BECAUSE WE ARE HANDLING OF THE INFRASTRUCTURE
FOR YOU THAT YOU CAN DO THINGS THAT
DON'T MAKE SENSE. SO PROCESSING
IN BATCHES IS A GOOD EXAMPLE. EVEN
THOUGH WE SCALE TO, YOU KNOW, WHATEVER
YOU WANT, YOU SHOULD STILL BE TAKING
ADVANTAGE OF INFRASTRUCTURE. TAKING
ADVANTAGE OF WHAT INFRASTRUCTURE
YOU HAVE PROVISIONED. SO WHAT I
MEAN, IF YOU HAVE AN APPLICATION
THAT IS SAY TAKING MESSAGES OFF
THE EVENT HUB, MAKE SURE THAT YOU
ARE CONFIGURED WITH THAT HUB TO
TAKE A BUNCH AT ONCE BECAUSE EACH
EXECUTION CAN ACTUALLY DO MORE THAN
JUST ONE MESSAGE. IN JAVA SCRIPT,
USE THIS CARDINALITY PROPERTY ON
THE JSON FILE. OR IF YOU'RE USING
C#, IT'S IN THE TYPE ANNOTATION,
SET THE EVENT DATA. SO THAT'S A
NICE LITTLE TRICK THAT I THINK EVERYONE
SHOULD TAKE ADVANTAGE OF. IT'S THE
DEFAULT IN THE TEMPLATES BUT WE
STILL SEE PEOPLE THAT THINK THEY
SHOULD BE DOING ONE MESSAGE AT A
TIME. BUT IT DOES MAKE MORE SENSE
TO BATCH YOUR PROCESSES. AND ACTUALLY
I WAS RUNNING SOMETHING -- WORKING
LIKE THIS LAST WEEK, HAD MAYBE 100,
000 VENTS SITTING ON AN EVENT HUB.
EARLY INLY NOT BATCHING AND CHANGED
TO USE BATCHING AND IT KIND OF CHANGED
THE PERFORMANCE FOR SOMETHING THAT
TOOK, YOU KNOW, LIKE AN HOUR TO
HAND IT WILL REQUEST TO SOMETHING
THAT TOOK MAYBE 10 MINUTES AND JUST
ONE THING TO NOTE, WHEN YOU ARE
USING EVENT HUB, AZURE FUNCTIONS
ONLY SCALES TO THE NUMBER OF PARTITIONS
BECAUSE WE HAVE TO GUARANTEE IN
ORDER OF PROCESSING WITHIN A GIVEN
PARTITION. FOR EVENT HUBS OR ANY
KIND OF APPLICATION WHERE YOU'RE
PULLING THINGS OFF THE CUE, BATCH,
MAKES THINGS SO MUCH SMOOTHER. ANOTHER
KIND OF GOTCHA. WHAT IS THE PROBLEM
WITH THIS PIECE OF CODE? THAT'S
CORRECT. THE HTTP CLIENT IS PER
EXECUTION. SO THIS IS AN ANTIPATTERN
BECAUSE IF YOU'RE IMAGINE YOU HAVE
A FUNCTION SCALING OUT DYNAMICALLY,
TO MAYBE 10, 000 REQUESTS, THIS
CREATES A NEW CLIENT ON EVERY INVOCATION
OF THAT FUNCTION. AND THAT'S OBVIOUSLY
NOT A GOOD THINGS BECAUSE CREATION
OF A CLIENT IS EXPENSIVE. AND ALSO
NOT BEING REUSED. SO BECAUSE FUNCTIONS
LIVE ON A FUNCTION APP, YOU CAN
ACTUALLY REUSE SOME RESOURCES BETWEEN
THEM. SO WE ADVISE DOING THINGS
LIKE CREATING STATIC OF THE HTTP
CLIENT. THIS WILL, THE FIRST TIME
IT'S NEEDED, IT WILL CREATE A CLIENT
AND IT WILL BE USED BY ALL INVOCATIONS
OF THAT FUNCTION. SO THIS IS A GOOD
WAY TO GET AROUND THAT ANTI-PA EARN.
SEE PEOPLE DOING THIS ALL THE TIME.
PREVENTS SCALING OUT PROPERLY. SOMETHING
YOU SHOULD TAKE NOTE OF DOING DATABASE,
THINGS LIKE THAT. ANYTHING WHERE
YOU HAVE TO CREATE A CLIENT CONNECTION.
AND ANOTHER THING I WANT TO ANNOUNCE,
WE ANNOUNCED THIS EARLIER TODAY,
THE SUPPORT FOR DEPENDENCY INJECTIONS.
THE IDEA IS NOW WE HAVE THE ABILITY
TO ACTUALLY INJECT A SERVICE INTO
THE LIFE CYCLE OF YOUR FUNCTIONS
SO YOU CAN SAY WHEN YOU ARE CREATING
A FUNCTION APP FOR THE FIRST TIME
RATHER THAN -- WELL, A GOOD WAY
TO ACTUALLY MANAGE THE LIFE PSYCH
OF THE SERVICE AND SAY THIS SERVICE
WILL BE AVAILABLE FOR THE LIFETIME
OF THE FUNCTION. THIS IS PROBABLY
MOST COMMON. YOU CAN ACTUALLY CONNECT
INTO THIS SERVICE THAT YOU PROVIDED
ELSEWHERE. SO TAKE ADVANTAGE OF
IT. IF YOU NEED IT, YOU KNOW YOU
NEED IT, AND THAT'S DEFINITELY A
REALLY GREAT NEW CAPABILITY THAT
WE ANNOUNCED THIS WEEK. ALL RIGHT.
SO THE FIRST COUPLE EXAMPLES THAT
I HAVE GONE THROUGH HAVE BEEN FOCUSED
ON YOUR INNER LOOP DEVELOPMENT,
WRITING CODE DAY-TO-DAY. I REALLY
ENCOURAGE EVERYONE, EVEN IF YOU'RE
A DEVELOP WE ARE AN OPS TEAM ELSE,
CONSIDER YOUR OUTER LOOP AND THINK
ABOUT THE THINGS AROUND THE LIFE
CYCLE OF THE APPLICATION. FIRST
AND FORE MOST IS MONITORING. IT'S
A REALLY GREAT TOOL. AND WE PROVISION
BY DEFAULT WHEN YOU CREATE A FUNCTION
APP. YOU CAN STREAM LIVE METRICS,
SEE, ALL THE REQUESTS, FUNCTION
APP IN THE LAST X AMOUNT OF TIME.
THAT JUST REALLY EMPHASIZE YOU SHOULD
BE USING APPLICATION INSIGHTS AND
IN ALL OF THE FUNCTION APPS AND
JUST THAT'S KIND OF THE JUST THE
WAY TO GO. THE OTHER COOL THING,
ENABLED FOR FUNCTIONS THAT HAVE
BEEN TRIGGERED BY SERVICE BUS AND
YOU CAN -- SO I SHOULD EXPLAIN WHAT
IT IS FIRST. THE APPLICATION MAP.
IN INSIGHTS. THE COOL THING, YOU
CAN TRACE THE LIFE CYCLE OF A GIVEN
EXECUTION AND SEE WHAT HAPPENS AS
WE'RE PASSING THROUGH THERE. YOU
CAN GO INTO THIS DISTRIBUTED NETWORK
TRACE AND SEE WHAT ACTUALLY HAPPENED
FOR A GIMP INVOCATION. BUT THE COOL
THING IS THAT FOUR PARTICULAR SERVICE
BUS, YOU CAN SEE HOW THAT FUNCTION
WAS PASSED BETWEEN DIFFERENT FUNCTION
APPS AND THAT INVOCATION WAS PASSED
BETWEEN CUES AND KIND OF GOING THROUGH
AZURE. SO FOR OTHER TRIGGERS AND
FUNCTION, THIS IS ENABLED. UNFORTUNATELY,
WE DON'T HAVE THE LINES YET. SO
YOU CAN STILL -- YOU CAN SEE WHERE
THE FUNCTIONS WERE TRIGGERED AND
HOW KIND OF EVERYTHING IS STITCHED
TOGETHER. BUT THE ONLY ONE WHERE
YOU GET THE NICE REALLY PRETTY TRAFFIC
LIGHT GRAPH HERE IS WITH SERVICE
BUS AS OF TODAY. THE NEXT THING,
ALONG THE SAME LINE OF OUTER LOOP
MANAGEMENT OF YOUR FUNCTION APPS,
I WOULD SAY WE ARE ANNOUNCING THIS
BETTER INTEGRATION WITH AZURE PIPELINES.
THAT'S SOMETHING THAT'S NEW THIS
WEEK. AND YOU CAN AZURE PIPELINES
WITH FUNCTIONS IN THE SENSE THAT
AZURE PIPELINES IS A GENERIC COMPUTE
PROVIDER, A BUILD SERVICE THAT LET'S
YOU CONFIGURE YOUR BUILD, SHIP THAT
CODE UP TO AZURE. AZURE DEVOPS SUPPORTS
EVERYTHING BUT WE HAVE MADE THE
INTEGRATION NICER. SO THE FIRST
ONE IS THAT IN THE PORTAL, WE HAVE
NICE TEMPLATES FOR AZURE FUNCTIONS
NOW. SO IF YOU SEARCH AZURE FUNCTIONS
IN AZURE DEVOPS, YOU CAN SEE WHAT
BUILD STEPS ARE NECESSARY FOR WHATEVER
LANGUAGE STACK AND THEN BE ABLE
TO DEPLOY YOUR FUNKS HOWEVER YOU
NEED. IN THE AZURE PORTAL ITSELF,
IN THE FUNCTIONS PORTAL, THERE'S
A DEPLOYMENT CENTER. SO THIS IS
NEWER UX THAT WE HAVE RELEASED RECENTLY.
IT ALLOWS YOU TO EASILY CONFIGURE,
I WOULD LIKE THE CODE TO COME FROM
HERE, BE BILL EVERBUILT BY THIS
SERVICE AND DEPLOYED TO HERE. SO
IT'S KIND OF A SIMILAR EXPERIENCE
AS IN THE DEVOPS PORTAL BUT IN THE
CONTEXT OF AZURE FUNCTIONS AND THE
LAST ONE IS THAT WE RELEASED AN
AZURE COMMAND TO DO THE SAME THING.
IT'S AZ FUNCTION APP PIPELINE BUILD
CREATE IS THE ACTUAL COMMAND. THE
IDEA HERE IS THAT YOU ARE IN THE
CONTEXT OF THE AZURE ON YOUR LOCAL
MACHINE AND YOU WANT TO CREATE A
PIPELINE FOR THE FIRST TIME. A GUIDED
EXPERIENCE THAT WILL HELP YOU GET
UP AND RUNNING OFF THE GROUND. AND
THEN FROM THERE, YOU ACTUALLY THE
LINK INTO THE PIPELINE THAT YOU'RE
GONE AND ACTUALLY PROVISIONED WITH
THIS COMMAND. COOL. SO MOVING ON.
WE'RE GOING TO GET INTO THING NUMBER
FIVE, MINIMIZE OR MITIGATE COLD
START. THIS IS SOMETHING THAT'S
REALLY IMPORTANT IN SERVERLESS.
SOMETHING YOU WILL HEAR A LOT OF
PEOPLE TALKING ABOUT. SORRY, JUST
OPENING UP THE TIMER. SERVERLESS
IS SOMETHING THAT'S KIND OF A REALITY
WITH SERVERLESS APPLICATIONS. COLD
START IS FOR THOSE WHO DON'T KNOW
THE FACT THAT THE FIRST TIME, MAKING
A REQUEST TO A SERVERLESS FUNCTION,
YOU HAVE TO DEAL WITH SOME LATENCY
HIT BECAUSE WE ACTUALLY HAVE TO
PROVISION THE RESOURCES FOR. SO
BECAUSE WE SCALE TO ZERO, WE DON'T
KEEP EVERYTHING RUNNING AT ALL THE
TIME AND IT WILL GET SLOWER THE
FIRST TIME. AND SCALING OUT, SMALL
COLD STARTS AS WELL BECAUSE WE'RE
STARTING AT ONE INSTANCE AND GETTING
BIGGER AND BIGGER. SO THE NEW INSTANCES
WILL TAKE SOME TIME TO GET STARTED
AS WELL. THOSE AREN'T AS BAD BECAUSE
YOU ACTUALLY HAVE THE EXISTING RESOURCE
TO GO AND KEEP CONNECTING TO. BUT
SOMETIMES THIS IS A THING THAT PEOPLE
RUN INTO AND HAVE ISSUES WITH. SO
A COUPLE TIPS WITH DEALING WITH
COLD START. FIRST, JAVA SCRIPT.
F #, C#, AND THOSE ARE THE THREE
GENERALLY AVAILABLE LANGUAGE STACKS.
AND THE IDEA HERE IS THAT WE'VE
PUT A LOT OF EFFORT INTO OPTIMIZING
THESE. THESE THE ONES YOU SHOULD
BE USING FOR PRODUCTION APPLICATIONS
AND ARE THE ONES THAT WE ENDORSE
AS THOSE WE HAVE OPTIMIZED AND ARE
IMPROVING. SO THAT'S THE FIRST BIT.
USE THE GA STUFF. BEYOND THAT, I
WOULD SAY THE NEXT ONE IS THESE
TWO VERY UNINFORMATIVE ICONS. THE
FIRST ONE IS DEPENDENCIES. THE THINGS
YOU'RE BRINGING INTO YOUR APPLICATION.
BRINGING THE WHOLE WORLD INTO THE
APPLICATION AND LOADING IT ON AZURE,
IT'S GOING TO TAKE LONGER TO START.
SO ALL THIS IS TO SAY, IF YOU HAVE
SAY A NOTE APP WITH A GIANT ENTRY,
MAKE SURE YOU PRUNE THAT. ONLY ACTUALLY
SHIP UP TO AZURE THE DEPENDENCIES
YOU NEED THE APPLICATION. BECAUSE
OBVIOUSLY AS YOU BRING IN MORE AND
MORE FILES AND HAVE MORE AND MORE
DEPENDENCIES, YOUR STUFF IS GOING
TO TAKE LONGER TO START. AND THIS
ONE IS AGAIN, NOT A GREAT ICON,
BUT IT'S JUST SUPPOSED TO SAY GO
WITH THE STUFF THAT WE ENDORSE.
WE HAVE A LOT OF DIFFERENT CONFIGURATIONS
THAT YOU CAN USE FUNCTIONS IN. AND
WHAT WE ADVISE IS USE THE TOOLING
THAT WE HAVE BUILT IN. SO WE HAVE
VISUAL STUDIO CODE. WE HAVE VISUAL
STUDIO, ALL OF THESE PIECES OF TECH
THAT WE RELEASED ALREADY USE THE
MOST OPTIMIZED METHOD. LIKE FOR
INSTANCE WE HAVE SOMETHING CALLED
RUN FROM PACKAGE THAT'S KIND OF
MORE ADVANCED RUNTIME TECHNIQUE
THAT IS KIND OF VERY CONFUSING AND
DEALT WITH MORE AS A DEPLOYMENT
TECHNOLOGY. YOU DON'T NEED TO WORRY
ABOUT THIS. WE'RE RUNNING THE APPLICATION
FROM A ZIP FILE RATHER THAN FROM
LOOSE FILES OPENED ON YOUR PROVISIONED
RESOURCES. ACTUALLY REALLY, REALLY
COOL TECH KNOWLEDGE. LIKE MOUNTED
IN MEMORY. VERY COOL. THE CORE IDEA
IS IT'S AN OPTIZATION THAT WE TAKE,
THAT WE DO FOR OURSELVES THAT MAKES
PERFORMANCE IMPROVEMENT AND WE DO
THAT BY DEFAULT FRONT-RUNNER ALL
OF THE DEPLO DEPLOYMENTS FROM LOCAL
ENVIRONMENTS SO TAKE ADVANTAGE OF.
THAT USE THE STUFF WE ADVISE IF
YOU KNOW WHAT YOU'RE DOING BY ALL
MEANS, GET INTO IT AND DO MORE.
MORE ADVANCED THINGS BUT THE ONES
WE ENDORSE ARE THE ONES THAT ARE
THE MOST PERFORMING AND THE VAST
MAJORITY OF CASES. AZURE FUNCTIONS
CAN RUN IN A VARIETY OF WAYS. I'VE
BEEN TALKING ABSERVERLESS. SERVERLESS
IS WHERE YOU GET THE DYNAMIC SCALE,
SCALED TO ZERO. AND THE APPLICATION
WILL RESPOND TO EVENT, PROVISION
AND INSTANCES, ET CETERA. AND THEY CAN RUN IN
THE DEDICATED PLAN WHICH IS RUNNING
ON APP SERVICE INFRASTRUCTURE. SO
RUN YOUR FUNCTION IN AN APP SERVICE
PLAN ALONG SIDE A WEB APP OR ITS
OWN SET OF RESOURCES. AND WHAT WE
RELEASED IS THIS PREMIUM PLAN WHICH
I LIKE TO THINK OF AS THE BEST OF
BOTH WORLDS SO. THE IDEA THAT YOU
PAY FOR AT LEAST ONE DEDICATED INSTANCE
AND SCALE ON TOP OF THAT. SO WHERE
THE PREMIUM PLAN, YOU GET MORE ADVANCED
NETWORKING FEATURES RUN ON BETTER
MACHINES ITSELF. SO IT IS SLIGHTLY
MORE EXPENSIVE. KIND OF THE SAME
PRICE AS A DEDICATED INSTANCE PLUS
WHATEVER DYNAMIC SCALE YOU GET ON
TOP. IT'S SERVERLESS IN THE SENSE
THAT IT SCALES SERVERLESSLY, YOU
AREN'T PAYING ZERO, YOU ARE PAYING
FOR AT LEAST ONE INSTANCE SO AT
LAST THE BASE COST. BUT. BUT ALSO
NEED TO MAKE SURE THAT THERE'S NO
COLD START AT ANY TIME. THAT'S WHY
I HAVE MITIGATE COLD START AS WELL.
YOU CAN AVOID THE PROBLEM ENTIRELY
BY PAYING US FOR MORE RESOURCES.
LAST THING SIX, GO INTO BUILDING
SERVERLESS APIs. SO THIS IS A WORKLOAD
THAT I THINK A LOT OF PEOPLE DO,
BUT DOESN'T GET ENOUGH BUZZ, I THINK.
IT'S A GOOD FIT FOR SERVERLESS.
BECAUSE OF THE FACT THAT IF YOU'VE
GOT AN API END POINT, IT'S A CONNECTION,
YOU DON'T KNOW WHEN PEOPLE ARE GOING
TO ACTUALLY HIT THAT END POINT,
IT'S A REALLY GOOD FIT FOR SERVERLESS
BECAUSE IT CAN SCALE AS YOU NEED
IT TO. SO THIS IS A CLASSIC ARCHITECTURE
OF MAYBE AN APPLICATION THAT YOU
HAVE RUNNING. MAYBE TWO DIFFERENT
SERVES, BUILT BY DIFFERENT TEAMS
PERHAPS. CONNECTING TO DIDN'T DATABASES
AND WHAT I WOULD SAY IS SERVERLESS
IS A GOOD WAY TO MODERNIZE THAT.
MAYBE YOU NEED TO RIP OUT AND BUILD
FUNCTIONALITY. SO IT'S EASY TO REPLACE
ONE EXISTING SERVE WITH A SET OF
SERVERLESS APIs. YOU DON'T ACTUALLY
HAVE TO REPLACE THINGS. YOU CAN
TACK THEM ON. SO IMAGINE YOU HAVE
AN EXISTING API AND YOU JUST WANT
TO MAYBE ADD THIS ONE LITTLE END
POINT THAT DOES SOME OF OTHER PIECE
OF WORK ON YOUR WEBSITE OR SOMETHING
LIKE ADDING SOME OTHER MODULE. I
DON'T KNOW. THE IDEA THAT IT'S VERY,
VERY EASY BY USING FUNCTIONS TO
PUT THAT ALONG SIDE THE EXISTING
API AND KIND OF JUST GOING FROM
THERE. IT'S VERY EASY TO GET UP
AND RUNNING. SO THAT'S ONE OF THE
MAIN SCENARIOS WHEN I SUGGEST SERVERLESS,
MODERNIZING AN EXISTING APPLICATION
AND THE OTHER ONE IS BUILDING A
NEW APPLICATION. THIS IS AN EXAMPLE
OF A ARCHITECTURE I'M FOND OF AND
SOMETHING I USE. IT IS SINGLE PAGE
APPLICATION. SO YOU'VE GOT A STATICALLY
HOSTED APP. AND I DON'T HAVE TO
WORRY ABOUT THE BIG SERVER. I ONLY
WANT TO HAVE SIMPLE SERVERLESS APIs
THAT RESPOND TO WHATEVER END POINTS
I NEED THEM TO. MAYBE I DO HAVE
STATE THAT I NEED TO MANAGE OR MAYBE
I HAVE SECRETS THAT I NEED -- LOGIC
I NEED TO PERFORM. SO THIS IS A
REALLY GOOD WAY OF DOING THAT. DOESN'T
NEED TO BE IN A NOSQL DATABASE BUT
IT'S A COOL BAY OF BUILDING SIMPLE
APPLICATIONS. SO THAT'S ONE I ENDORSE
SUPER HEAVILY AS WELL. SO WITH THAT,
I WANT TO GET INTO -- THAT'S THE
END OF MY TALK BUT I WANT TO TALK
THROUGH QUICKLY WHAT IS NEW IN AZURE
FUNCTIONS. WE HAVE THE REALLY COOL
EVENT PROGRAMMING MODEL WITH KUBERNETES.
SO WE ANNOUNCED THE PARTNERSHIP
WITH RED HAT. IT'S AN EVENT-DRIVEN
SCALE. YOU CAN SCALE TO ZERO IN
KUBERNETES WHICH IS SOMETHING WE
COULDN'T DO BEFORE. THE WAY I LIKE
TO THINK OF THIS, THE SCALING BEHAVIOR
IN AZURE MIMICKINGED IN A KUBERNETES
ENVIRONMENT. PREMIUM FUNK, I WON'T
GO TOO DEEP THERE A PREVIEW OF POWERSHELL
THIS WEEK. EXTENSION BUNDLE, SOMETHING
THAT IS ONE OF THOSE FEATURES THAT
ENABLES A LOT OF THINGS FOR A LOT
OF NON-. NET DEVELOPERS THAT YOU
SHOULDN'T HAVE TO WORRY ABOUT. BUT
THE IDEA IS RATHER THAN HAVING TO
INSTALL INTECH, WE WILL BUNDLE THEM
TOGETHER AND CONFIGURE FOR YOU HOW
YOU GO AND ACTUALLY NEGOTIATE THAT.
FOR NON-. NET DEVELOPER, YOU DON'T
NEED . NET INSTALLED ON THE MACHINE.
SO YOU DON'T NEED IT WHICH IS REALLY
GREAT AND SHOULD HAVE ALWAYS BEEN
THE CASE. ANYWAY. WE HAVE A DURABLE
FUNCTIONS RELEASE. 2. 0. HAS THE
ENTITIES THAT REALLY COOL. THE STREAMLINED
AZURE DEVOP SUPPORT. AND WE HAVE
A NEW SERVERLESS LIBRARY EXPERIENCE.
SO THIS SERVERLESS LIBRARY IS A
GREAT -- THERE WE GO. IT'S A REALLY
COOL SET OFS THAT PEOPLE BUILT.
AN OPEN SOURCE GALLERY OF THINGS
THAT PEOPLE BUILT WITH FUNCTIONS
AND OTHER TECHNOLOGY. WE RECENTLY
IMPROVED THE UX. WE HAVE THE ABILITY
TO ADD SAMPLE TOES ON THE SITE.
MORE DETAILS ABOUT EACH SAMPLE,
FILTER AND GO AND SEARCH THROUGH
TO FIND YOUR MOST -- FIND THINGS
THAT ARE OTHER PEOPLE ARE DOING.
I THINK IT'S GREAT. CHECK IT OUT.
CONTRIBUTE A SAMPLE FLORIDA YOU
BUILT SOMETHING WITH FUNCTIONS.
AND ALSO, CHECK OUT MORE SERVERLESS
SESSIONS. WE HAVE THESE -- HAVE
ALREADY HAPPENED. THIS IS ME. SO
YOU WENT TO THIS. AND THEN THESE
ARE ALL OF THE OTHER SESSIONS AS
WELL. CHECK THEM OUT. PARTICULARLY
SOME OF THE LONGER SESSIONS LIKE
THIS ONE. IT'S GOING TO BE GREAT.
YEAH. SO THANK YOU EVERYONE. THAT'S
IT. I'LL PUT IT BACK ON THE SLIDE
FOR EVERYONE TO TAKE PICTURES IF
YOU WANT. BUT YEAH, THANK YOU ALL