DockerFile

Vamos a ver como crear una nueva imagen a través del fichero Dockerfile.

Recordemos que Dockerfile es simplemente un fichero de texto que nos permite definir las instrucciones a seguir por Docker para construir una imagen.

Deben estar guardados dentro de un build context (directorio el cuál contiene todos los archivos necesarios para construir nuestra imagen). El nombre del fichero es Dockerfile sin extensión.

Una buena práctica es crear el archivo .dockerignore que nos ayudá a definir lo que realemente necesita el directorio de contexto . Con este archivo, puede especificar ignorar reglas y excepciones de estas reglas para archivos y carpetas, que no se incluirán en el contexto de compilación y, por lo tanto, no se empaquetarán en un archivo ni se cargarán en el servidor Docker.

Ejemplo sencillo de un archivo Dockerfile:

FROM ubuntu

ADD . /app

RUN apt-get update RUN apt-get upgrade -y

RUN apt-get install -y nodejs ssh mysql

RUN cd /app && npm install

# esto debería iniciar tres procesos, mysql y ssh

# en segundo plano y node app en primer plano

CMD mysql & sshd & npm start

Instrucciones que podemos usar para crear un Dockerfile:

FROM — Especifica la base para la imagen.

ENV — Establece una variable de entorno persistente.

ARG — Permite definir una variable usable en el resto del Dockerfile con la sintaxis ${NOMBRE_DEL_ARG}

RUN — Ejecuta el comando especificado. Se usa para instalar paquetes en el contenedor.

COPY — Copia archivos y directorios al contenedor.

ADD — Lo mismo que COPY pero con la funcionalidad añadida de descomprimir archivos .tar y la capacidad de añadir archivos vía URL.

WORKDIR — Indica el directorio sobre el que se van a aplicar las instrucciones siguientes.

ENTRYPOINT — Docker tiene un Entrypoint por defecto, /bin/sh -c, que se ejecuta cuando el contenedor está listo. Este comando permite sobreescribirlo.

CMD — Especifica el comando y argumentos que se van a pasar al contenedor. Se ejecutarán junto con lo indicado en el Entrypoint.

EXPOSE — Indica que puerto del contenedor se debe exponer al ejecutarlo. No lo expone directamente.

LABEL — Nos permite aportar meta-datos a la imagen.

VOLUME — Crea un directorio sobre el que se va a montar un volumen para persistir datos más allá de la vida del contenedor.

USER — Establece el usuario que se va a usar cuando se ejecute cualquier operación posterior con RUN, CMD y ENTRYPOINT.

SHELL — Permite especificar el uso de otra terminal, como zsh, csh, tcsh, powershell, u otras..

STOPSIGNAL — Indica una señal que va a finalizar el contenedor.

HEALTHCHECK — Indica a Docker una manera de testear el contenedor para verificar que sigue funcionando correctamente.

ONBUILD — Cuando la imagen donde se encuentra se use como base de otra imagen, va a actuar de trigger y va a ejecutar el comando que le indiquemos.

Comandos Docker

•  docker image muestra todos los comandos  que podemos usar sobre las imágenes.

• docker container  muestra todos los comandos que podemos usar sobre los contenedores.

• docker pull NOMBREIMAGEN . Este comando sirve para descargar una imagen.

• docker images  muestra imágenes que tenemos descargadas.

• docker ps -a    muestra los contenedores disponibles en tu host.
  

• docker run IMAGE_ID, creará y ejecutará un contenedor basado en esta. Si la imagen no existe, Docker primero la obtendrá desde el Hub.

• docker build [OPTIONS]  <nombre_imagen> construye una imagen

• docker rmi  IMAGE_ID elimina imagen.

• docker rmi `docker images -q` elimina todas las imágenes.

• docker info  Muestra informacion de las imagenes, tamaño , fecha creacion  nombre ,…

• docker search NAME   para buscar en docker.

• docker stop NOMBRECONTENEDOR detener un contenedor

• docker logs <friendly-name|container-id>

En su web podemos.encontrar más información sobre los comandos y sus opciones.

Docker

Docker es una plataforma de contenedorización que se utiliza para desarrollar, enviar y ejecutar contenedores.Es un conjunto de tecnologías que te permiten ejecutar aplicaciones con sus dependencias (llamaremos imagen) dentro de un contenedor, consta de varios componentes que utilizamos para crear, ejecutar y administrar nuestras aplicaciones en contenedores

Uno de los puntos fuertes de la creación de contenedores es que no tiene que configurar el hardware ni perder tiempo instalando sistemas operativos y software para alojar una implementación.

Los contenedores están aislados entre sí y varios contenedores pueden ejecutarse en el mismo hardware. Esta configuración nos ayuda a usar el hardware de manera más eficiente y puede ayudar a mejorar la seguridad de nuestra aplicación. 

Imagen

Una imagen es una representación estática de la aplicación o el servicio y de su configuración y las dependencias.

Una imagen podría contener un sistema operativo con un servidor y una aplicación web instalada.

Hay que tener en cuenta que las imagenes son archivos inmutables de solo lectura, si creas un contenedor a partir de una imagen, y mientras  se está ejecutando el contenedor se cambia algo o se instala alguna herramienta, al parar dicho contenedor y después volver a ejecutar otra vez la misma imagen, esos cambios no se verán reflejados.

Si queremos que los cambios realizados en el contenedor se mantengan, una de las opciones sería la de generar una imagen a partir del contenedor, para ello haríamos lo siguiente:

docker commit -m "<comentario>" -a "<autor>" <id_contenedor> <nombre_imagen>:<etiqueta_imagen>

Hay muchas imágenes públicas con elementos básicos como Java, Ubuntu, Apache…etc, que se pueden descargar y utilizar. Normalmente para crear imágenes, lo hacemos a partir de una imagen padre a la que le vamos añadiendo lo que vayamos necesitando 

Las imágenes se almacenan en un registro, que sirve como biblioteca de imágenes.(DockerHub).

Para crear una imagen utilizaremos un Dockerfile,que es un archivo de texto plano que contiene una serie de instrucciones necesarias para configurar una imagen. 

Ejecutando el comando docker build sobre ese DockerFile, se nos creará la imagen correspondiente.

 

A partir de una única imagen, podemos ejecutar varios contenedores. 

Contenedor

 Un contenedor es un espacio donde se ejecuta la imagen.

Docker se divide en dos ediciones:

• Docker Community Edition (CE). Se trata de un entorno de desarrollo y ejecución de contenedores basados en Docker que es gratuito y sencillo de utilizar.

Posee dos canales de actualización:
        Edge: De liberación mensual y en la que solo se proporcionará soporte a bugs                     y fallos de seguridad durante el mes en curso.
        Stable: De liberación trimestral con cuatro meses de soporte

• Docker Enterprise Edition (EE). No es gratuita, provee contenedores certificados y viene con 3 versiones:

                        Básica:  viene con la plataforma, el soporte y la certificación de la ventana                                               acoplable.

                        Estándar y Avanzada: incluyen la administración de contenedores y las                                                               funciones de escaneo de seguridad de la ventana                                                               acoplable agregadas a las funciones de la edición básica. 

Como hemos dicho anteriormente si se destruye una imagen, se pierden los cambios que se han realizado sobre ella, para poder guardar (conservar) esos datos o para compartir datos entre contenedores, existe el  concepto de volúmenes ,que son directorios (o archivos) que están fuera del sistema de archivos de unión predeterminado y existen como directorios y archivos normales en el sistema de archivos del host.

La forma más directa es declarar un volumen en tiempo de ejecución con el indicador -v :

Spring Boot

 Cuando construimos un proyecto con Spring lo pasos que realizamos son:

1. Crear proyecto maven y descargar las dependencias

2. Desarrollar la aplicación

3. Desplegar en el servidor.

Spring Boot nos facilitará los pasos 1 y 3.

Spring Boot permite compilar nuestras aplicaciones Web como un archivo .jar que podemos ejecutar como una aplicación Java normal, esto lo consigue integrando el servidor de aplicaciones en el propio .jar y levantándolo cuando arrancamos la aplicación.

Entre las principales características de Spring Boot se encuentran:

• Contenedores Java embebidos: Tomcat o Jetty

• Soporte para la automatización con Maven y Gradle

• Configuración sugerida para iniciar rápidamente con un proyecto (Starters)

• Configura automáticamente Spring, cuando sea posible

• Características listas para producción: métricas, seguridad, verificación del estatus, externalización de configuración, etc.

• No genera código y no requiere configuración XML
  

Starters

Un starters es esencialmente un conjunto de dependencias  que son específicas para el tipo de aplicación que el iniciador representa y se utilizan para limitar la cantidad de configuración manual de las dependencia.

Los starters siguen la nomenclatura: spring-boot-starter-XXX, donde XXX es el tipo de aplicación que se quiere desarrollar.

Ejemplos de starters que más se suele utilizar:

• spring-boot-starter-web se utiliza para desarrollar servicios web de RESTful con Spring MVC y Tomcat como el contenedor de aplicaciones incorporado.

• spring-boot-starter-jdbc se utiliza para el agrupamiento de conexiones JDBC. Se basa en la implementación del grupo de conexiones JDBC de Tomcat.

En esta página podemos encontrar muchos más indicadores.

Crear una aplicación 

Se suele utilizar alguna de estas dos formas:

• Con la ayuda del IDE (Spring Tool Suite).

• Con ayuda de la página de Spring Boot (https://start.spring.io/).
  

Orden de inicialización

Así, en primer lugar se inicializan los campos estáticos de las clases, desde la primera superclase hay abajo;

Acontinuación, la primera superclase inicializa sus campos de instancia, y ejecuta el código contenido en ellos;

Acto seguido, la primera superclase ejecuta su constructor;

Luego, la siguiente subclase inicializa sus campos de instancia y ejecuta el código que contienen;

Por último, la subclase ejecutan su constructor.

 

Los últimos dos puntos se repiten por cada subclase, en orden de herencia.

Arrays Unidimensionales

• Estructura básica

 int[] myArray = new int[];

int two[]=new int[];

int[] three =new int[]{1,2,3}; //array 3 elementos con valores 1,2,3

int[] four={};

El tamaño de los arrays se pone en la inicialiación del mismo:

int[3] prueba; //error de compilación

Lo correcto sería:

int[] prueba = new int[3]; 

int[] prueba = {}; 

int[] prueba2=new int[]{1,2,3}

• Comparación de Arrays

String[] animales = {"Perro","Gato","Pez"};

String misAnimales = animales;

String otrosAnimales =  {"Perro","Gato","Pez"};

System.out.println(animales == misAnimales); //true

System.out.println(animales.equals(misAnimales)); //true

System.out.println(Arrays.equals(animales,misAnimales)); //true

System.out.println(animales == otrosAnimales ); //false

System.out.println(animales.equals(otrosAnimales )); //false

System.out.println(Arrays.equals(animales,misAnimales)); //true

* Arrays.equals(array1, array2) compara el contenido de los arrays.

* ==  y equals compara dirección de memorias.

Se utiliza la propiedad length para saber el tamaño del arrya.

• Valores de los arrays 

Pasando el valor en concreto que queremos recuperar (se empieza a contar desde 0):

                                        0         1          2

String[] animales = {"Perro","Gato","Pez"}; 

 System.out.println(animales[0]); //Perro 

 System.out.println(animales[1]); //Gato
 System.out.println(animales[0]); //Pez.

 Mediante un for:

  for(int i=0;i

       System.out.println(animales[i]);                         

   }

Se imprimirá Perro Gato  Pez .

toString:

Arrays.toString(array) se imprime los valores del array entre corchetes y separados por coma:

        System.out.println(Arrays.toString(dos)); [Perro,Gato,Pez]

    

Hay que tener en cuenta que si usamos array.toString lo que se imprimirá es su representación en memoria de este objeto:

                                       System.out.println(dos.toString()); [Ljava.lang.String;@15db9742

Ocurriría lo mismo si hacemos 

                                       System.out.println(dos); [Ljava.lang.String;@15db9742

Se puede modificar los valores de los arrays:

                                                   animales[0]="Caballo";

• Arrays.sort

 Se utiliza Arrays.sort(array);  para ordenar los elementos del array unidimensional.

• Arrays.binarySearch

Busca un elemento específico en toda una matriz unidimensional y ordenada,

Arrays.binarySearch(array, valorBuscar);

 

Sí encuentra el valor devuelve el indice de la posición donde se encuentra y si no exisie devuelve la posocion en negativo de donde debería estar el valor.

Si el array no está ordenado devuelve un valor impredecible.

INSERT comprobando antes que no exista

Se puede hacer de dos formas:

Insert into TABLE (CAMPOS) select CAMPOS a insertar from dual where not exists (select null from table where codigo = CODIGO);

O con un procedure:

DECLARE   
     V_CONTADOR NUMBER(10):=0;  
BEGIN
 
    SELECT count(*) INTO V_CONTADOR FROM TABLE WHERE CAMPO=VALOR;
 
  IF V_CONTADOR=0  then
    Insert into TABLE(CAMPOS) values (CAMPOS);   
  END IF; 
 
END;