Deep dive into fundamental knowledge about microservices and background information about the concepts behind the microservices architecture approach.

Microservices Architecture

In this module we’ll learn about microservices in depth and understand the reasons for using and not using microservices. We’ll also learn about micro and macro architecture, strategies for migrating old systems, the role of Docker in this architecture, and technologies for implementing microservices like Spring Boot and Go.

After this module, you’ll be better equipped to implement microservices.

An Introduction to Microservice Principles and Concepts

## Overview

The creation of Docker images is done via files named
`Dockerfile`. One of Docker's strengths is that Dockerfiles are easy
to write and therefore, the rolling out of software can be automated
without any problems.

The typical components of a `Dockerfile` are:

* `FROM` defines a base image on which the installation is based.
  A base image for a microservice usually contains a Linux
distribution and basic software, such as the JVM, for example.

* `RUN` defines commands that execute to create the Docker
image. In essence, a `Dockerfile` is a shell script that installs the
software.

* `CMD` defines what happens when the Docker container is started.
Typically, only one process should run in one Docker container. This
is started by `CMD`.

* `COPY` copies files in the Docker image. `ADD` does the same;
however, it can also unpack archives and download files from a URL on the
Internet. `COPY` is simpler to understand
because it does not extract archives, for example. Also, from a
security perspective, it can be problematic to download software from
the Internet into Docker containers. Therefore, `COPY` should be given
preference over `ADD`.

* `EXPOSE` exposes a port of the Docker container. This can then be
contacted by other Docker containers or can be tied to a port of the
Docker host.

A comprehensive
[reference](https://docs.docker.com/engine/reference/builder/) is
available on the Internet which contains additional details to the
commands in
`Dockerfile`.

## An example for a Dockerfile

A simple example of a `Dockerfile` for a Java microservice looks like
this:

FROM openjdk:11.0.2-jre-slim
COPY target/customer.jar .
CMD /usr/bin/java -Xmx400m -Xms400m -jar customer.jar
EXPOSE 8080

* The first line defines the base image with `FROM`. It is downloaded from the public Docker hub. The image contains
  a Linux distribution and a Java Virtual Machine (JVM).

* The second line adds a JAR file to the image with `COPY`. A JAR
file (Java ARchive) contains all components of a Java application. It
has to be available in a sub directory `target` below the directory in
which the `Dockerfile` is stored. The JAR file is copied into the root
directory of the container.

* The `CMD` entry determines which process should be started when the
container is started. In this example, a Java process 
runs the JAR file.

* Finally, `EXPOSE` makes a port available to the outside. This is the port
under which the application is available. `EXPOSE` only means that the
container provides the port. It is then available on the internal
Docker network. Access from outside is only possible when this is
enabled at the start of the container.

The Docker image can be built with the command `docker build
--tag=microservice-customer microservice-customer`. 

`docker` is the
command line tool with which most functionalities of Docker can be
controlled. The created Docker image has the tag
`microservices-customer` as defined by the `--tag` parameter. 

The
`Dockerfile` has to be in the sub directory `microservice-customer`.
The name of this directory is the second parameter.


# Overview

The creation of Docker images is done via files named
`Dockerfile`. One of Docker's strengths is that Dockerfiles are easy
to write and therefore, the rolling out of software can be automated
without any problems.

The typical components of a `Dockerfile` are:

* `FROM` defines a base image on which the installation is based.
  A base image for a microservice usually contains a Linux
distribution and basic software, such as the JVM, for example.

* `RUN` defines commands that execute to create the Docker
image. In essence, a `Dockerfile` is a shell script that installs the
software.

* `CMD` defines what happens when the Docker container is started.
Typically, only one process should run in one Docker container. This
is started by `CMD`.

* `COPY` copies files in the Docker image. `ADD` does the same;
however, it can also unpack archives and download files from a URL on the
Internet. `COPY` is simpler to understand
because it does not extract archives, for example. Also, from a
security perspective, it can be problematic to download software from
the Internet into Docker containers. Therefore, `COPY` should be given
preference over `ADD`.

* `EXPOSE` exposes a port of the Docker container. This can then be
contacted by other Docker containers or can be tied to a port of the
Docker host.

A comprehensive
[reference](https://docs.docker.com/engine/reference/builder/) is
available on the Internet which contains additional details to the
commands in
`Dockerfile`.

# An example for a Dockerfile

A simple example of a `Dockerfile` for a Java microservice looks like
this:

In this lesson, we'll discuss Dockerfiles.

Microservices

Micro and Macro Architecture

Migration

Docker

Technical Micro Architecture

Appendix

Conclusion

Dockerfiles

Overview #

An example for a Dockerfile #