-: In last section,
we finished up our single container deployment
over to Amazon Elastic Beanstalk.
Before we move on, quick reminder,
please do not forget to terminate the application
that we just put together.
I put directions
for terminating the app in the last section.
Kind of a quick text section that shows you very
quickly how to terminate the application.
You need to terminate that thing
so that you do not get billed money.
If you're okay with paying a couple of bucks,
then you can certainly leave the application running.
But if you don't want to be billed any money,
then please make sure that you terminate the application.
All right, so we finished up the application
on the entire deployment successfully,
but there was a couple of big-ticket items
in there that I think were kind of big issues.
Things that we did not quite do as well as we could have.
So here are some of the issues that I think we ran
into with that single container deployment process.
First off, the entire application was very simple.
It was a single React application backed
up by an NGINX server.
Not a real a lot of complexity there.
We weren't relying upon any outside services
or databases or anything like that.
And so I think that if we are going to really get mastery
of containers and deployment and all that kind of stuff,
we might need to work
on an application that is a little bit more complex.
And maybe has kind of a intermix
of a couple of different services.
The other thing that I wanna point out is
that we were building our image multiple times.
We built out our image over
on Travis CI when we ran our tests,
and we also built the image a second time
after we pushed all of our code through Travis
over to Amazon Elastic Beanstalk.
And I'm gonna suggest that,
maybe that wasn't the best approach
because we were essentially taking our web server
or the web application,
and we were using it to build our image.
Chances are, we really want our web server
to be just concerned with running our web server,
and we probably don't want to have it to have
to do this extra process of building out our image.
So I think that maybe that was kind of a bad approach
to allow our Docker image to be built multiple times,
and most especially, allow it to build
on our active running web server.
The third item and this is very close related
to the first one we just spoke about,
we had a very simple, very straightforward application.
It did not make use of any outside services.
So there was no database that we made use of,
no API, no Redis server for caching or anything like that.
So I think that if we really want to get some mastery
of Docker and really understand how this stuff works,
we probably need to work
on a little bit more complicated application.
And that's exactly what we're gonna start doing
in this section.
We're gonna figure out
how to build a multi-container application
that makes use of multiple different databases
or sources of information, tie it all together with Docker
and Docker Compose, and then eventually deployed off
to Amazon Beanstalk as a multi-container application.
So let's take a quick pause right here.
We're gonna continue in the next section,
and we're gonna talk about the specifics
of the application that we're gonna put together.
So I'll see you in just a minute.