Learn about OpenShift on Azure Government

Learn about OpenShift on Azure Government


>>Hi, this is Steve Michelotti from the Azure Government
Engineering Team. Today, I’m joined by
Jamie Duncan from Open Shift and we are going to be talking about Open Shift on Azure
Government. Welcome Jamie.>>Hi, good morning,
how are you doing?>>So, I guess we should
just start out by telling us all a little bit
about what is Open Shift?>>Yeah. Well, it
goes a lot of ways, Open Shift is a lot of
things to a lot of people and it’s hard to go and the best definition I
can come up with is that Open Shift is Kubernetes, which is one of
the biggest buzzwords on IT, one of the most popular open source projects out
there on the planet. Open Shift is
an application platform that’s enterprise grade that comes with all of
Red Hat support, all of Red Hats efforts with Kubernetes as
it’s beating heart. So, it’s an application platform that has all of that flexibility that’s leveraging
containers underneath to give you your applications.>>Okay. All right. So let’s go into
a little bit more depth. Oftenly, used in CI/CD pipelines?>>All the time.>>Okay.>>That’s where a lot
of that power is. We talk about automation, we talk about all of
these great fun things and if I had to build
out 15 Virtual Machines, every time I wanted to
launch a CI/CD platform, my Dev and Stage Environments
would have to be massive. We just don’t have
those resources. We always have to figure out
how to do more with less. We have to isolate
our processes more effectively. So, as more things
become more CI/CD, almost like a buzzword,
almost like a verb, that I’ve CI/CD this application. We have to figure
out how to do it in the tightest possible way and
the fastest possible way. If I have an application that
takes 10 minutes to build, I can’t wait 45 minutes
for my VMs supervision. I can’t have that overhead,
that operational overhead, taking a ton of time and containers where Virtual Machine
spin up in minutes, containers typically
spin up in milliseconds. Where we can spin up five or 10 or 20 on a given hypervisor, inside a single Virtual Machine, I can run 50 or 100 containers depending on what
the application is.>>Okay.>>So, we just get
that economy of scale, we get economy of speed. They make CI/CD way
more practical. Those back to
those heady days of, “I’m going to launch my build
and then go have lunch”, we don’t have to do that anymore. It’s great times. So, all of that containers
and Kubernetes and Open Shift really makes CI/CD more practical for way
more applications.>>All right. So, what else
should we talked about to set up our eventual demos here?>>Yeah. So we have a couple of demos that we’re
going to do today, anytime I do a presentation, I always have to have
a little good luck charm, always stick a little about
me slide in because it’s fun. I’ve been at Red Hat
about seven years, I’ve been working with our government customers
that entire time. So, the customers, they are the people that
consume Azure Gov. I’ve worked with
every major government agency out there and one of
the things I really like to think about the way I like
to talk to my customers is I try to be
that long focus lens, I try to find customer problems in the health care industry,
in the health care, CMS and the NIH and figure out how
those problems are affecting what’s going
on in homeland security, figuring out what’s going on in other Civilian agencies or DOD agencies and try to be that long focused lens with
a breadth of experience. Seven years in the government
is like dog years. I always take a picture
of my daughter Elizabeth because she’s the cutest
thing on the planet. This picture was from
last week when she was showing us all how
to wear sunglasses. It was just fun and then a little bit of
a shameless plug, yes she really is that cute. A little bit of a shameless plug
John Osborne and I, another Solutions Architect inside for
Red Hat Government, we have a book about
Open Shift out, 320 some odd pages. It’s the first time
someone tried to talk about the developer
experience and the operations experience and Open Shift and Kubernetes
all under one set of covers. We go all the way
down to the bottom of the kernel and then we come all the way back up to the top of the application
stack including a really complex CI/CD
Pipeline in chapter six which is the impetus
for this first thing. Open Shift is
Enterprise Kubernetes, that’s what we just talked about. It’s using the beating heart
of Kubernetes, all of that power, of
that massive community, it’s growing, it’s
consistently one of the top five opensource
Projects on the planet, it did massive growth, massive amount of work happening. We’re taking all of
that and we’re putting the extra pieces on top
of it to make OpenShift, that makes it an enterprise
consumable product. We test OpenShift
up to 2,000 nodes. So, you can have a 2,000
node OpenShift Cluster and Red Hat is going to support
it for production outages. It brings in a routing layer
to make it easy, to get in and out of your applications from
outside the cluster, Kubernetes doesn’t
come with that. Configures a software to find network for Kubernetes to use, Kubernetes doesn’t come
with one out of the box. So, we take all those things
that makes Kubernetes hard, that you see on Twitter and we just make it work out
of the box that way. So that’s what opensource->>So, taking all the goodness
that we already have in Kubernetes and sprinkling some
OpenShift’s magic on top to make it easier to use.>>Exactly. We make it so it takes an hour to
deploy, not four days.>>Yeah.>>In fact, I’ll be doing a deploy later
this week and we’re planning on about an hour for a production running cluster.>>Okay. Great.>>It’s good stuff. But all of those bits and
computer geeks like us, we always get obsessed with
the new shiny and we go into our customers and we talk about the new shiny and
we might get them excited about it but we’re not really helping
them bring value, we talk about projects that
are months or even years away from being ready to be deployed in a datacenter
for the government. I try not to do that
with OpenShift, I try not to do that
with Containers. There’s so much power there, that we do it, that we can bring that value and we can make
their lives better. I think at the end of the day, whether we’re talking about DevOps or CI/CD or whatever
buzzword we want to use, we have to help them
fulfill mission. We have to help them
make their job easier, through a couple of
bullet points up here, we have to make the Dev or
the Ops guys lives better. They have to be able to
do more with less money. I’ve talked to and I’m
sure you have too, hundreds of government customers
in the past year, nobody has a bigger budget
next year than this year. So, we always have to
do more with less. We have to streamline workflows, automation is the only way
we’re going to survive these days and CI/CD is really, just really complex automation.>>Yeah. We talk about
how can we spend taxpayer dollars
more efficiently, enable the mission,
focus on the mission. As a developer, I like to get up there and talk
about shiny lines of code but the reality is
it’s not about that, it’s about how you can bring those efficiencies
to the customer.>>This awesome algorithm
I wrote doesn’t matter if->>No one cares about it.>>It doesn’t fulfill
our mission better, if it doesn’t save us
money in the long run. Just being awesome isn’t
good enough anymore. So, that’s really where
we like to focus on. So, the first demo
we put together is- when I think about value especially
public clouds like Azure, the ability to bring as many different kinds of
workloads into them without having to
drastically change those workloads to me is
a huge value proposition.>>Definitely.>>The first one
is that Legacy app and people talk about
it all the time, there are entire books
written about how you can’t bring a Legacy app into
a cloud native world, into a cloud ready or a
public cloud provider. You really can, if you
can get the app to run in a container you can bring the entire thing inside
OpenShift into Azure. Even if you have requirements
that aren’t great, if you have hard, I ran into this just
a few months ago. A customer had literally a hard-coded requirement
for NFS in the application, they couldn’t not use
NFS and NFS we all know is a great tool but production
is not its middle name. So, even if you have
those hard-coded requirements, even if you have really
complex deployment processes, using multiple
different third party tools, which is what we’re actually
going to be doing here, you can bring all of
that into OpenShift. All of that tooling runs in.>>This is a super
important use case, especially in
the government space. Of course, it’s nice if you can rewrite your application and use all these great cloud native
bells and whistles but the reality is that government customers and
agencies get pressure like, “Get your stuff to
the cloud right now.” How can we do that?
What does that mean?>>Yeah. Every single
government agency has a Cloud, has a public cloud policy now. If they’re not serious about it, it’s just really they don’t
know how to be serious about it because they
have these Legacy apps. So, the first demo, it’s a Java app, it’s a monolithic designed
app on purpose, we’re using Jenkins,
we’re using SonarQube for QA testing to
actually run the testing, it’s using Nexus as
its artifact repository. The source control is in Git, we’re using Gogs which is this containerized Git repository GitHub
clone essentially. All of that is
deployed in OpenShift. So, let’s trigger this workflow. I’m going to do literally a
Git push from my laptop into an OpenShift cluster running on Azure Gov and we’ll watch
the pipeline build out.>>All right. Great.
Yeah. This is a great example
because here you have, of course, Azure Government with, if you have an environment, you need compliance and whatnot but you have
the OpenShift goodness, just sitting right there in
your compliant environment.>>Yeah. So, I’m able to abstract away some of
that cloud nativeness.>>Yeah, definitely.>>Bring in and insulate my Legacy workloads using
tools like OpenShift.>>Cool.>>So, I am miles away from
being a Java developer, I’m an old Ops guy and this
is also I just want to say, I am a laptop Linux
user for a long time. This is VS Code. VS Code
is pretty awesome, we were talking about it
before we started filming. I may be a convert to
VS Code even on Linux.>>It has quickly
become the most popular Microsoft opensource
project out there.>>It’s pretty,
pretty awesome stuff.>>So, we’ll save this off. I just commented out
an ignore clause and ignore decorator. So, we’re actually going to run this test and I’m
really just looking for something to do that
and then troll S.>>You’re going to
push your code?>>Yeah.>>So, we will add
all of our changes. We’ll give a message. We’ll get a good comment, “getting rid of
ignore decorator.”>>There you go.
Since they’re almost->>Exactly yeah, exactly. Then we’ll commit our code.>>Yes.>>Then, we will “Push.”>>Great.>>It’s going to ask
me for my username. All right. Now, we haven’t looked
at OpenShift yet.>>Yeah. All we’ve done
is make a simple push.>>Yeah, exactly. This is
the front page of OpenShift.>>Right.>>Let me get rid of
this little filter here. So, you have all these buttons, all of these different
things I can do, but I also have the CI/CD
project that I created. I did create this ahead of time a little infomercials diary. You see here all of
my applications. I have gogs, which is
our source control for today, and it’s just a GitHub clone.>>Okay.>>You can see here,
getting rid of ignore decorator,
there’s my Git Push. So, from my laptop sitting
here in Redmond, Washington, this went out to the Azure
Gulf Cloud and got committed.>>So, that part worked.>>Awesome.>>So, we’re good to go so far.>>We have Jenkins
running, and if we look here we have a Jenkins build
pipeline going already. This is going to take
us a couple of minutes, because it’s going
to pull down some information from the get-go.>>But what I see is I
hope that is obvious to people right off the bat is that we’re running all this
on Azure Government. This is just a
legacy application.>>We didn’t force you to
use SQL server or out of C#.>>We didn’t do any of that.>>We didn’t force
you to use BSTS, it’s running on Jenkins.>>This is you’re taking
your existing solution with your existing tools and platforms and doing all this.>>Right.>>This is pure roll OpenJDK. This is pure Java, no frameworks or anything
that I’m aware of.>>Great.>>So, you see it’s
building the app now. So, it’s got a pull down some
information because this is the first time I’ve
built it in this project. So, just walking through
what’s going to happen, we’re going to build the apps. We’re going to build the Java
application run through put all the artifacts and the next is pull him out do whatever
needs to happen, build a container image
it has my application. We’re also going to
test run through your SonarQube to
test all of the code.>>Okay.>>Show a test coverage,
do all of those things.>>It’s happening right now. You’ve checked in the code, and the CI/CD Build is running.>>Yes, and it is running
in the background.>>Okay.>>Here’s Nexus,
our Nexus Repository. It’s doing all the
stuff that it’s doing. We haven’t quite
gotten to that step yet I jumped the gun a little.>>Okay, it’s fine.>>SonarQube. SonarQube was one
those apps that didn’t exist when I was
an everyday admin kind of stunned that there is
a tool that had to do all this awesome code checking. But again, all of this is
running inside OpenShift. All of this is container ready. These are off-the-shelf
components. So, I can bring my environment in, drop these legacy apps, and run them against
the CI/CD tooling products that have been out
there for ages.>>Awesome.>>That can bring
very complex environments very quickly into OpenShift.>>Okay.>>All right. So,
our application is built or at least it’s further down
through the pipeline now. Let’s go see what
we’ve got done so far. So, we’ve built our application. So, we’ve built a container that house run our application. We’ve built that
container on the fly. No docker files, no anything. No knowledge of really even
how a container works.>>Yeah.>>We just took our
application, we took Maven, and we built it
all together using a templating technology that’s inside OpenShift that just
works out-of-the-box. We’ve ran our test
suite against it, we ran our code analysis against it with open with clarity.>>Looks like they’d
test just 13 seconds.>>Yeah.>>All right.>>Great.>>We’re on our full
unit test suite. Code analysis took 29 seconds. We’ve archived our apps, so we’ve archived it into Nexus, that took 10 seconds. Now, we’re creating
our image builder. Now, we’re getting
ready to actually deploy our application
into another project.>>Okay.>>So, this particular
pipeline will deploy into what we call a project
inside OpenShift, which is just a
logical separator. It’s going to deploy
into a dev environment where our app will
be up and running.>>Awesome>>Then it’s going to
actually prompt us. Once we go look at
our app and running the additional human
tests we want, we click a button, and now, it’s actually creating
the dev environment.>>Okay.>>Then once we decide
the dev is okay, it’s actually going to deploy to a staging environment for us.>>Okay.>>So, we have a full CI/CD
workflow inside here, inside of three minutes, and all of the times
are down in here. So, now that all
these tests are done, we can go actually go
look at SonarQube, and we see if our test passed. So, we have one project analyzed. It found two bugs with
one vulnerability and 17 things didn’t
quite smell right.>>Yeah.>>But if we look at
our project they’ve got now, I love the fact that
it says code smells.>>Yeah.>>That just makes me laugh. We found two bugs, we can go in and see what
those bugs are. These are pretty old ones
that I’m going to get fixed in this version of OpenJDK. Seventeen code smells,
we got an A. We don’t have great test
coverage, but we’ll get there. That was the thing
that I committed out to actually run some tests, to do some test coverage. Zero duplications and
it’s 2,000 lines of code.>>All right, great.>>None of that existed. So, we did all of this on the fly.>>Okay. So, the deployment
is still happening right now?>>Should be done by now.>>Okay.>>We’ve created dev and
we’ve deployed to dev, which took zero seconds.>>Awesome.>>Now, it’s actually waiting on us to see if we want to deploy. Again, this is visualization
of Jenkins inside. So, we can go look at, now we go look at
our dev environment. Tasks, this application’s name is openshift tasks, here we are. OpenShift deployed
my application, and built me a route into it. So, it gave me a URL to go look at my application
automatically.>>Okay.>>Yeah.>>I like that, yeah.>>All of it is just done.
At the end of the day, what does this developer want? Developers don’t want to
be rude on Linux servers. Developers don’t want to
have to go be bad admins.>>Right.>>Developers want a place
to write their code, and a place to push it, and
the URL to go look at it.>>Exactly.>>The rest of it, they just want it to
be automated away.>>Exactly. That’s awesome. Okay, so we took a Legacy app
and we deployed it using OpenShift in a matter
of three four minutes.>>Exactly. Three minutes live, having never deployed even to this OpenShift cluster before.>>Okay.>>Here it is. The app
is up and working. We can click all these buttons. These things actually send
stuff into log files. Essentially, it’s
a unit testing tool.>>Yeah.>>We can generate load against our container for
however many seconds we want. But we say okay, the app is done. We’ve decided dev is okay, dev has passed all of
our user acceptance testing. We still have that
pipeline running, and it says, “Input required.” My pipeline is paused now. It’s going to pause
until, just like Jenkins. This is a Jenkins pipeline.>>It’s like a workflow.>>Yeah, and I have Jenkins integrated with
the same authentication that my OpenShift is using.>>Okay.>>Sometimes
this login takes a few seconds, but were there. I’m ready promote to stage. We don’t need to
remember that password.>>Okay, great. Let’s get
to the choice right here.>>I just click “Promote”.>>Yeah, and there it is.>>Okay.>>Jenkins is
deployed and then we see the actual
pipeline working if Jenkins is an
environment you’re more familiar with and it’s done. We go back and look at OpenShift,
it’s deployed to stay.>>Nice, four seconds, okay,
sounds good.Okay, great.>>So, anytime I do a good push, all I have to do is push my code and that pipeline gets built up. That idea of CI/CD, that would take a huge amount of resources to do in
a traditional environment. And if we’d look inside
our application, we have our metrics deployed. The Git server is taking 51 megabytes of memory off
of my system right now.>>Okay. Can’t complain
too much about that.>>Exactly. When was the last time you built a VM that had 51 megabytes per mm?>>Right, right. Okay, cool.>>Just that loss of overhead.>>Okay, so we deployed
the Legacy app, what are some other types
of apps we can deploy?>>Right. So the other
value proposition, and we’ll talk a little bit about that future-looking cloud native 12 factor thing here in a minute, but a huge portion of
the work that we do, the work that our customers
do in the government, I just call them
simple applications. They don’t have
these giants CI/CD workflows, a team of one or two
people wrote them. They keep them in
a version control system, they update them once
every six months, and they just update them. This is actually an example
that we used from the book I have to
pull it up here. A simple Image Uploader. So I have literally just
a Git repository. This is a PHP application
that I think is maybe one page and it lets
you select a box, you pick a picture, and
you upload it into it. Done and done. We’ll
clone it here. This is GitHub that everyone
should be familiar with, especially people at Microsoft.>>Oh, yeah, we love GitHub.>>You guys know a little
about GitHub, yeah? So we’ll deploy this
completely from scratch.>>Okay, so different
application, this is no longer
a Java application, this is->>No, this is a PHP app.>>PHP app. Okay, great.>>Yeah, we’ll create
a project. We’ll create one of those logical separators and we’ll call it Image Uploader. Image Uploader app
and click “Create”. We can go in there, I
haven’t deployed anything. So I can browse our catalog
and that’s where this catalog comes in and we’ll
come back to what the catalog can do here
in the few minutes. But I can browse by
“Language” and go to “PHP” and I can tap what
we call a builder image. A builder image inside OpenShift, it’s PHP and the web server and when you tell it
the source code to put in it, there’s a little bit of JSON
in there that it knows where to put the source code to
deploy it so it functions. Sort of a quick start. So we just tell it it’s PHP, we tell it which version
of PHP we’re going to use. We give it a name Uploader and we tell it the URL
that we pull from.>>So I’ve just given it
a Git repository right there.>>That’s all the
information you need.>>That’s the only thing
it needs other than our pretty display names.>>Yeah, exactly.>>Okay.>>And I click “Create”. We’ll go to our “Project Overview”. Now, this one obviously can take a couple of seconds to
build the first time. We can actually watch
it in real time. We can watch it
download everything. It’s going to pull
these files in, it’s going to take
that builder image, it’s going to take
my source code, it’s going to make a custom
container image from them.>>Kind of standard
container functionality.>>Exactly. And
then it’s going to take that custom
container image and push it into the registry that’s inside OpenShift that
comes out of the box. Another one of those great
little value adds that [inaudible] on its own doesn’t
come from and it’s done.>>Okay. Now, do you have
configurability of where the container registry lives or that’s always
the OpenShift registry?>>By default, it’s
the OpenShift registry. It can be an external registry
like Artifactory.>>Or it could be
Azure container registry.>>If you want it to be.>>OpenShift registry,
it’s your choice.>>Exactly. You can tell
OpenShift where to look. But our saying “Default” is we’re going to have
one running internally.>>Makes sense.>>And there are a couple of
bits and hooks in there that work but you can
configure all of that. You can look at external,
you can look at 15 or 20 different registries depending on what your people do.>>Awesome, okay.>>So this app built even
before you ask the question.>>Okay, great.>>And it also gave
me a URL to go to.>>Love that.>>Exactly.>>Click the button,
and there it is. I’m not a Front-end
Web Developer, so you’ll forgive
my shades of gray, but I’ll pick a file. Here’s our picture of
Elizabeth swimming. Here is Elizabeth holding
some big giant foam swords. Most of my pictures
are Elizabeth related, and it’s done. Files uploaded.>>Okay, and where did
it upload the file to?>>It uploaded it by default. It uploaded into- I’ll get rid of our picture
of Elizabeth here. It uploaded it to
the ephemeral storage that’s inside the container. But I can add persistent storage to
a container after I deploy it. So just by simply clicking->>Or you could even add the Blob storage if you wanted to, it’s really
your choice [inaudible] code.>>So with OpenShift- Blob,
not quite there yet.>>But you can just
write PHP Code, just store it in Blob storage.>>I could go directly
to the PI. Exactly.>>Yeah, exactly.>>By default, out of
the box Kubernetes has plug-ins that work with
Azure Disk and Azure File. So I can use the
Azure File Store or I can create Azure Disks
dynamically on demand and attach them to the host
that my containers are using and then present them into the container and
all of that’s automated->>Cool.>>-by default so I’ve already
provisioned some storage. So I can just go right here to “Uploader”, “Actions”,
“Add Storage.” I hit the wrong button. We don’t need to autoscale this application,
although that’s another->>Interesting feature.>>Another fun feature, yeah.>>[inaudible] storage.>>Yeah, so we have what we
call a horizontal autoscaler. So, “Creative Storage”. We’ll call this one
Image Uploader. I have multiple ways- different
storage providers have different types of
different abilities. Obviously, the
Azure Disk Storage, I can’t present the same disk to two VMs at the same time. So I can’t present it to
two containers at the same time.>>Yeah.>>So, it can only do Read/Write,
single user Read/Write. Other technologies that
can have where I could attach it to 50 containers
across 50 hosts. So, I can do Read/Write many. It’s depending on the technology.
We’ll do single user. We write and these we’re not going to do
a whole bunch of pictures. So we’ll just say
one gigabyte easy peasy. Click “Create”. I go to “Storage” now for
this project and I see that “Image Uploader”
“Storage Request” and there’s this concept inside OpenShift of separating
the request for storage, which is part of my application
from the actual storage, which is part of
the control plane that could separation
of concerns that DevOps mentality is inherent in everything that
OpenShifting Kubernetes do.>>Okay, great.>>So already, I had an available
storage volume that met my capacity and my storage type requirements and
it mounted in it, bound it to that storage request.>>Okay, so those were
a couple of awesome demos. What can you tell us
about some of the Azure integration we have
with OpenShift?>>Yeah, so a lot of that is it’s actually pretty amazing. So, we talked for the most part, we’re talking about legacy
apps and these sort of these everyday applications, the smaller applications, but the way we’re going
to be deploying apps, the way we’re going
to be building things out over the next few years is really that
12 Factory Microservice, take our code and
integrate it with multiple managed services to
get our job done.>>Yeah.>>We don’t want to have to write a search engine because
you guys have a search engine. We don’t want to have to manage a Postgres Database because you guys provide one or Cosmos.>>Yeah.>>All of that is integrated into OpenShift out of the box. In this environment, this one I deployed on Azure Gov
a few days ago, I deployed what’s called the open service broker for Azure.>>Okay.>>Took me about 15 minutes. Yeah, it’s a follow
five or six steps instruction, s drops some stuff in
the command line and it was done and you can see here, when we did the
earlier demo where we deploy the PHP application, I had that builder image
and I was able to click on it and say and follow
the instructions. We have over 100 other
applications that we deploy from. There’s a bunch of JBL stuff
that comes out of the box. No JS databases.
All sorts of fun stuff. Ruby applications,
different databases, all these things
that we do out of the box to a bunch
of.Net Core stuff and all of this just
comes with OpenShift.>>Yeah.>>So, all of
these builder images, all these quick starts, all these very templated
automated deployments. What the advert Azure
service broker does and I’ll just filter back on filter
down on the word Azure. It gives me a bunch of
services that are in Azure Gov that I can deploy from inside OpenShift and more importantly than deploy from
inside OpenShift. OpenShift is now aware of them.>>Okay.>>So that they become part of my application’s life cycle. So that if I need to make
changes to say the Azure search if I deploy that as part of
my applications ecosystem, I can now script changes into Azure Search because
OpenShift is aware of how to interact with the part of the Azure API that creates
and modify search for me.>>So it almost
becomes like a part of your solution manifest source.>>Exactly.>>Okay.>>Yeah.>>Makes sense.>>They all of
those things become part of my ecosystem for
my application. The open service broker
for Azure, OSBA. Because need to work on
the acronym a little bit. It’s something that’s a little more pronounceable than OSBA.>>All right.>>But we’ll get there.>>Yeah.>>It’s a little new since some of these is still
may have some of these options are
still experimental and searches among them, but Cosmos DBs with
different APIs. So there’s I can
deploy a Cosmos DB and use the Mongo API or
the SQL server API. All of those it’s aware of all of those changes and then I can
just take that application. So just again, so just to if
we want to deploy a cosmos, tell it what I want it to do, tell it which project I wanted
to add it to that image if my image upload
or if I wanted to stop writing them directly
to persistent storage, I’m going to put
them in a database.>>Yeah.>>Deployed into
that Image Uploader application. I select all those options that Azure needs for Azure to be
able to do its job correctly.>>That’s basically
connection information [inaudible] done this correctly.>>Exactly. I create a secret inside my
application that contains my connection information
so it’s encrypted and that’s it and then I click the “Create” button
and I’m off to the races.>>Sounds good, okay.>>It’s all that easy. We take that stuff,
that hard stuff. Those that would take
a lot of coding->>Right.>>-to code against that API and then I’d have to learn how
to code against the API.>>Yeah.>>I think the point
click a few things. Let me go fulfill mission. Let me not have to learn-.>>Awesome.>>-50 new API
endpoints this week.>>Okay, great. So we’ve been
talking about OpenShift. You talked about
deploying legacy app. Even just deploying an app from GitHub that wasn’t
legacy as well as integrating with
server broker functionality all on Azure government.>>Exactly.>>Okay, great. Well, thanks
for joining us today.>>Yeah, thanks.>>This has been
Steve Michelotti of the Azure Government
Engineering Team here with Jamie Duncan from OpenShift.
Thanks for watching.

Posts created 19620

Leave a Reply

Your email address will not be published. Required fields are marked *

Begin typing your search term above and press enter to search. Press ESC to cancel.

Back To Top