All language subtitles for 34 - CCP EC2 Image Builder Hands On English

Okay, so let's practice using EC2 Image Builder.

So let's go into the EC2 Image Builder service

and have a play with it.

So I'm into the service,

we can get started, we can create an image pipeline.

And so here's our first pipeline,

we'll call it my demo pipeline,

and then we have the option to create a build schedule.

So as we can see here,

we can schedule it to happen every week on Monday at 9:00 AM

and customize this.

And we can also say that you should run

at the scheduled time only if there are dependency updates,

these kind of things,

or just run every time based on schedule.

We can specify CRON expression,

but we'll just have it manual

because we're running it manually in this hands-on.

I'll click on next,

next we are to choose a recipe.

And so a recipe is a document

that defines how the source image is going to be customized.

And we need to create a new recipe

because we don't have one yet.

And here we have two options,

we can create either an AMI

out of the EC2 Image Builder service,

or a Docker image,

but for this instance,

we'll use an AMI.

Okay, so we'll call it MyDemoRecipe.

We need to provide a version, so 1.0.0,

and then we need to select a source image.

So we can either create one from images created by AWS,

or enter a custom AMI ID.

So we'll just go with managed images,

we'll choose Amazon Linux 2,

but we have different options as well as you can see.

We'll scroll down,

the image origins going to be quick start

from Amazon-managed,

and for the image ARN,

please choose Amazon Linux 2 x86, okay?

Do not choose ARM64, choose x86,

otherwise you will see an error later on.

Then we'll click on use the latest available OS version,

we'll scroll down,

and here is the interesting part,

so components, is how do we want to customize our image.

So we can apply the build components

that are pre-created by AWS,

for example,

if we wanted to have Java on our image and our AMI,

currently, there is no Java on Amazon Linux 2,

but if you select amazon-corretto-11-headless,

then you would have Java 11 being installed on your AMI,

so great.

And if you go to the next page,

there's another thing I want to install

which is aws-cli-version-2-linux,

so currently only version 1 is installed onto my AMI,

but if I wanted to upgrade it to version 2

then I could select this build component.

And it is possible for you to really create

your own build component if you wanted to,

if you wanted to customize and install your own application,

for example.

Okay, so let's scroll down,

and as we can see now we have the two components,

we can reorder in which order they're going to be installed,

so we can say first install the cli-version-2,

and then install the Java 11 from Amazon called corretto.

Okay next, how do we want to test

that the AMI is working, post-build?

We have different tests available here,

we can create our own test,

but I'm going to skip this

because we don't want to run any tests on our instance.

And then I will click on next.

Okay so next, how do we want to create this AMI?

On what type of EC2 instances

do we want to create our image?

And so, as we can see here,

we can either create the infrastructure

using service defaults,

or create a new infrastructure configuration.

So we want to select the last option,

and for this we'll create an IAM role,

so we'll call it the IAM role here,

see we have to choose?

Currently we have no results available,

but I'm going to go ahead

and create a new role for EC2 Image Builder.

So I'll click on create new role,

and I'm going to roles,

and I'll go and click on create role

for AWS service,

and this is going to be a role for EC2 instances.

Next, permissions.

And so here we need to start attaching policies.

So if I go back to the EC2 Image Builder,

and click on create using service defaults,

it says that here,

in order to have a correct role,

we need to create a role name with this role name.

So I'm going to,

sorry, the role name will have a letter,

but we need to attach some policies to it.

So we need to attach this first policy, called the

EC2InstanceProfileForImageBuilder.

We need to attach the second policy,

which is ECRContainerBuilds

if we wanted to create Docker images,

and the last, we need to attach is

the AmazonSSMManagedInstanceCore managed policy.

So all these things are necessary

for EC2 Image Builder to work.

I click on add tags,

next review,

and the role name,

I'm just going to give the default role name right here.

So I'm creating this role manually

because when I did create it automatically,

it wasn't correctly working,

so I wanna make sure this is done correctly.

So we have this create role dialogue,

and we're good to go.

Okay, so the role has been created.

Here's my EC2InstanceProfileForImageBuilder

that has been created.

And now in the image builder,

I'm going to click on

create new infrastructure configuration,

MyDemoInfra,

and the IM role I'm going to choose

is the role I just created right now

called the EC2InstanceProfileForImageBuilder.

Okay, now why do we do this?

Well, because we want to be able to customize

the AWS infrastructure,

and as such, I want the instant type to be of type t2.micro,

and the reason I'm doing this

is that I really want to be able to run

on the fridge here for this hands-on,

so that you don't pay any money.

If you were to run with the default settings,

then it will start launching an M5 large instance,

and you will have to pay for it, obviously.

As you can see, the t2.micro only has the x86 architecture,

it doesn't have the ARM64,

and this is why we've selected an AMI that was x86,

and not ARM64.

So next I scroll down, click on next.

And then for distribution settings,

we can either use the default,

and see that my AMI

is going to be distributed in the region I'm in,

which is eu-west-2.

But you could create a new distribution setting,

and in here you can set up region 1,

but also set up region 2,

and region 3, for example,

if you wanted to distribute your AMI

to different regions automatically,

which is really, really handy,

but for this hands-on,

we'll just use a service defaults,

and have the AMI in one region.

I'll click on next.

Everything does look good to me,

and I will click on create pipeline.

Okay, so everything has been created.

Now, let's click on our pipeline,

MyDemoPipeline,

and I'm going to do action,

and run pipeline,

and this is going to start an execution.

And so here I can click on view details,

and we're going to go straight into the execution.

So here is the output image, it is pending.

I'm going to click on it,

this opens a new screen,

and I'm going to wait until the build starts.

Okay, so my instance is now in the building stage,

and so that means that if I go into the EC2 service,

I should start seeing an EC2 instance.

So let's go into the EC2 service,

let's close this, go to instances,

close this again,

and we have here our build instance for my demo recipe.

So this instance was created by EC2 Image Builder,

and you can verify it by going into tags, for example.

And you can see that the created by tag

is for EC2 Image Builder,

the Ec2ImageBuilderArn

corresponds to the image we created,

and the name is build instance for my demo recipe.

So some stuff is happening right now on my instance,

as we can see the IAM role for my instance

is EC2InstanceProfileForImageBuilder,

which is the role that we have created just before

that contains the three policies

that we've attached manually to make sure

that everything was working correctly.

So what I'm going to do now

is just pause the video,

and wait for the build stage to be done.

So I just refreshed the page,

and the status is now testing.

So let's go have a look at what's happening here.

So if I go into my instances and refresh this,

we can see that my builder instance has now been terminated,

because we have built the AMI from it,

and my test instance is now running.

And if I look at my test instance and scroll down,

we can see that the AMI right here,

which I'm going to click on,

the AMI is a new AMI that has been created.

And the AMI name is MyDemoRecipe,

and contains the timestamp of when it was created.

So now the test instance is actually launched

from this new AMI, and is being tested.

So this AMI, as we can see if we go to the tags,

has been created by the EC2 Image Builder service,

and we can see the ARN right here as well.

So this is quite cool,

because now we can see that the AMI

has been automatically created,

and now it's in the test phase.

So let's wait a little bit until the test is done.

Okay, so now the status is distributing,

so the test phase is now done,

so there was no test being run on our AMI, obviously,

but if they were any tests,

then the test instance would've been running this test.

So now the instant test is also being terminated

which is good.

And then we are in the last stage

which is the distribution setting.

So if we look at it,

right now we only distribute to one region,

which is eu-west-2,

which is where the AMI was created,

so nothing much is going to happen.

But if we were distributing that image

into the United States,

into Southeast Asia, all these kind of places,

then the distribution would happen right now.

Okay, so my image is now available,

and this was good.

So if you go to images,

we can see that it was created, so perfect.

So let's just make sure that it actually did

what I wanted to do.

So if I go and launch an instance,

so I will call this one,

Test from AMI,

and I will choose my AMIs,

and I will choose the demo recipe

that I just created using the EC2 Image Builder service.

I will scroll down,

I will choose t2.micro,

I will proceed without a key pair,

because I will use EC2 instance connect

to run some commands.

Then for network settings,

I'm going to edit it,

and then choose an existing security group,

I'll choose my Launch-wizard-1.

So we can ssh into our instance, scroll down,

and actually none of the rest is necessary,

so I'll just click on launch instance,

and I'm good to go.

So my instance is now launching.

So my instance is now running,

so I'll click on connect,

I will use the EC2 instance connect service

and the username has to change,

it is ec2-user,

because we created a custom AMI,

we need to tell AWS

that we still want to use the ec2-user user

which is coming from Amazon Linux 2.

So I am into my image,

and we can verify two things.

Number one, that the aws-cli version 2 was installed,

so as we can see, it says version 2.7.0,

so indeed version 2 was installed,

which is an upgrade,

and then we can also verify that Java was installed.

And for this, we can verify indeed

that's we are running the openjdk version 11,

which is Amazon Corretto 11.

So our EC2 Image Builder works,

and we exactly had the output we wanted.

So now just to clean up what we have,

let's just terminate our instance.

Next, what you can do is go into your AMIs,

and from here, you can actually deregister your AMI,

and finally, in snapshots,

you can take your snapshots.

And I got two, 'cause I got different ones

but take the snapshot that was created

by the EC2 Image Builder,

which is this one,

and then action, delete snapshots,

and you are good to go.

Okay, you can leave the pipeline running

because while this is a manual pipeline,

so it's not going to run on its own.

So that's it for this lecture,

I hope you liked it,

and I will see you in the next lecture.