Hello, and we to take a quick look at what happens after the build happens, okay, after it's all
built, we'll see where everything basically goes and what we get as a result.
And then a little anxious, we'll get into the testing and into deployment as well.
So this is not the very tricky part of it.
But I just want to give you an idea of what happens with that bill.
So we have the job.
OK, we have this one main job which happens, and it runs a few different things, OK?
And we get the result.
If it's checkmark success, that means it succeeded.
And then you see who ran the build.
You see where the code came from and all that stuff, how much time it took.
Usually not the most useful that arrived.
But then you see this whole thing published.
OK, if I click on that, you will see this offer folder structure into which it gets published.
So this is an artifact.
You see artifacts.
OK, now let's see what an artifact is.
We have job.
OK, so you saw previously the pipelines being built or BARABBA published artifacts, a pipeline, artifacts.
So we get a job.
And this whole arrangement, if you choose a different method of that, it would be different and hence
it wouldn't work.
OK, so we get job, we get new test results, things like that.
Lots of different things.
And then we get in the way.
We get example, API, zip, and then what we care about is we?
S OK, we care about the folder.
And this is where we find the built compiled unit, Project X unit project.
Right.
We have a project, we have a binary is everything that we need to actually run it.
And then we have the example API.
Now example API is a bit more tricky than the X unit.
We have to get it from a specific place.
You see that later.
If you don't get it from a specific place, it will basically just publish the whole thing.
And obviously that will not work.
And the IRS manager, so this is what you get as a result of these things do actually exist somewhere
on some kind of a virtual machine.
In other words, a server.
Right.
They do exist somewhere.
They aren't some magical things with artifacts.
These are basically just files.
It's just a fancy word they decided to use for them.
Right.
And if we go back, we can go back, OK?
And if you do get lost, if you do get lost in this somewhere, somehow you simply need to go back to
the pipelines.
And that's where you will see all your bills.
Right.
This is the pipeline was a whole build arrangement, which you can modify edit, OK?
And then once you go into that Esteva history and you receive it, completed builds a completed Milicic.
This is what we did previously, what we ran previously.
So we have this whole range and we are back.
OK, we are back now with all that.
With all that, we have a job.
Okay, job.
And this gives you an idea of what's happening in the console window right before the data and all that
stuff.
And this is very, very useful.
Obviously, if you run into an error or something is not working, you need to go through these files,
check what's happening, what has happened, what did not happen, what was found and what was not found,
what failed and what succeeded.
It can be a very painful process.
But if you follow along, hopefully this will work perfectly without having to add any modifications
to it.
So we have this arrangement.
And other than that, we don't really have anything too much.
Now, this is set up to create a release automatically, but we'll get to that in the next lecture's.
So this is how you build and at this point, to have your projects built or compiled.
Right.
You have your programs ready to launch, ready to be executed.
And in the next elections, we will take a look at how you test and deploy or publish them to the IRS
manager.