# SQL Server

{% embed url="https://mytcpip.com/2019/05/08/instalar-microsfot-sql-en-un-ubuntu-18-04-con-docker/" %}



Otra guia para comunicarse con java

[https://aripd.com/posts/mssql/](https://aripd.com/posts/mssql/)

## INSTALAR MICROSOFT SQL EN UN UBUNTU 18.04 CON DOCKER

written by [José Luis Sánchez Borque](https://mytcpip.com/author/gielsb/) May 8, 2019[![Instalar Microsoft SQL en un Ubuntu 18.04 con Docker](https://mytcpip.com/wp-content/uploads/2019/05/docker_facebook_share.png)](https://mytcpip.com/wp-content/uploads/2019/05/docker_facebook_share.png)

Docker es una aplicación que simplifica el proceso de administración de aplicaciones en contenedores. Los contenedores nos permiten ejecutar sus aplicaciones en procesos aislados de recursos. Son similares a las máquinas virtuales, pero los contenedores son más portátiles, más amigables con los recursos y más dependientes del sistema operativo del host.

En este tutorial, instalaremos y usarremos **Docker Community Edition (CE) en Ubuntu 18.04**.

**Prerrequisitos**

Debemos tener presente los siguiente antes de comenzar con la instalación:

1. Un servidor Ubuntu 18.04 adecuadamente configurado.
2. Una cuenta en Docker Hub si queremos configurar contenedores nosotros mismos ( opcional )

**Instalando Docker**

El paquete de instalación de Docker disponible en el repositorio oficial de Ubuntu puede no ser la última versión. Para garantizar que obtengamos la última versión, instalaremos Docker desde el repositorio oficial de Docker. Para hacerlo, agregaremos un nuevo origen de paquete, agregaremos la clave GPG de Docker para garantizar que las descargas sean válidas y luego instalaremos el paquete.

Primero, actualizamos la lista existente de paquetes:

```
root@mytcpip:~# apt update
```

Luego, instalamos algunos paquetes de requisitos previos que nos permitirán a apt usar paquetes a través de HTTPS:

```
# apt install apt-transport-https ca-certificates curl software-properties-common
```

Luego agregue la clave GPG para el repositorio oficial de Docker a su sistema:

```
# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
```

Agregamos el repositorio de Docker a las fuentes de APT:

```
# add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
```

A continuación, actualizamos la base de datos de paquetes con los paquetes de Docker del repositorio recién agregado:

```
# apt update
```

Nos aseguramos que estamos utilizando el repositorio de Docker en lugar del repositorio de Ubuntu predeterminado:

```
 sudo apt-cache policy docker-ce
```

Veremos algo similar a lo siguiente,  aunque el número de versión de Docker puede ser diferente:

```
apt-cache policy docker-ce
docker-ce:
Installed: 5:18.09.6~3-0~ubuntu-bionic
Candidate: 5:18.09.6~3-0~ubuntu-bionic
Version table:
*** 5:18.09.6~3-0~ubuntu-bionic 500

Tenga en cuenta que el docker-ce no está instalado, pero el candidato para la instalación es del repositorio de Docker para Ubuntu 18.04 (bionic).
```

Finalmente, instalamos Docker:

```
apt install docker-ce
```

Docker debería estar instalado, el daemon iniciado y el proceso habilitado para iniciarse en el arranque. Comprobamos que se está ejecutando:

```
root@mytcpip:~# systemctl status docker
● docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: e
Active: active (running) since Tue 2019-05-07 21:42:14 PDT; 19min ago
Docs: https://docs.docker.com
Main PID: 636 (dockerd)
Tasks: 10
CGroup: /system.slice/docker.service
└─636 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containe

May 07 21:42:13 mytcpip dockerd[636]: time="2019-05-07T21:42:13.560070906-07:00"
May 07 21:42:13 mytcpip dockerd[636]: time="2019-05-07T21:42:13.560118227-07:00"
May 07 21:42:13 mytcpip dockerd[636]: time="2019-05-07T21:42:13.560126561-07:00"
May 07 21:42:13 mytcpip dockerd[636]: time="2019-05-07T21:42:13.561771401-07:00"
May 07 21:42:13 mytcpip dockerd[636]: time="2019-05-07T21:42:13.975401749-07:00"
May 07 21:42:14 mytcpip dockerd[636]: time="2019-05-07T21:42:14.112369132-07:00"
May 07 21:42:14 mytcpip dockerd[636]: time="2019-05-07T21:42:14.269628727-07:00"
May 07 21:42:14 mytcpip dockerd[636]: time="2019-05-07T21:42:14.269990984-07:00"
May 07 21:42:14 mytcpip dockerd[636]: time="2019-05-07T21:42:14.279033432-07:00"
May 07 21:42:14 mytcpip systemd[1]: Started Docker Applicat
```

Ya tenemos Docker instalado en nuestro servidor Ubuntu.

```
root@mytcpip:~# docker version
Client:
Version: 18.09.6
API version: 1.39
Go version: go1.10.8
Git commit: 481bc77
Built: Sat May 4 02:35:57 2019
OS/Arch: linux/amd64
Experimental: false

Server: Docker Engine - Community
Engine:
Version: 18.09.6
API version: 1.39 (minimum version 1.12)
Go version: go1.10.8
Git commit: 481bc77
Built: Sat May 4 01:59:36 2019
OS/Arch: linux/amd64
Experimental: false
```

**Instalación de MS-SQL 2017**

En este tutorial veremos una forma rápida de instalar Microsoft SQL Server 2017 en nuestro Ubuntu 18.04

Vemos en primer lugar los requisitos previos:

1. Docker Engine 1.8+ con cualquier distribución de Linux compatible o Docker para Mac / Windows.
2. Docker overlay2 como controlador de almacenamiento.
3. Mínimo de 2 GB de espacio en disco.
4. Mínimo de 2 GB de RAM.

El punto 1 hemos visto con docker version que lo cumplimos. Tenemos la versión 18.09.06

El punto 2 lo podemos comprobar con docker info:

```
root@mytcpip:~# docker info
Containers: 0
Running: 0
Paused: 0
Stopped: 0
Images: 1
Server Version: 18.09.6
Storage Driver: overlay2
  Backing Filesystem: extfs
  Supports d_type: true
  Native Overlay Diff: true
Logging Driver: json-file
// LINEAS BORRADAS INTENCIONADAMENTE PARA ACORTAR EL TEXTO 
Insecure Registries:
127.0.0.0/8
Live Restore Enabled: false
Product License: Community Engine
```

Y los otros ya depende del ordenador donde esteís haciendo el laboratorio.

Bien en primer lugar exraemos la imagen del contenedor de Linux Server 2017 Linux del Registro de Microsoft Container.

```
root@mytcpip:~# docker pull mcr.microsoft.com/mssql/server:2017-latest-ubuntu
```

El comando anterior extrae la última imagen del contenedor de SQL Server 2017. Si queremos una imagen específica, tendremos que agregar dos puntos y el nombre de la etiqueta (por ejemplo, mcr.microsoft.com/mssql/server:2017-GA-ubuntu). Para ver todas las imágenes disponibles, podemos acceder a la página del concentrador [Docker del servidor mssql.](https://hub.docker.com/_/microsoft-mssql-server)

Veamos que imagen se ha descagado en mi máquina:

```
root@mytcpip:~# docker images

REPOSITORY TAG IMAGE ID CREATED SIZE
mcr.microsoft.com/mssql/server 2017-latest-ubuntu 644ca19cb10d 6 weeks ago 1.38GB
```

Bien para arrancar contenedor ejcutamos la siguiente instrucción ( todo en la misma línea):

```

docker run -e 'ACCEPT_EULA=Y' -e 'SA_PASSWORD=123456aA-19'  -p 1433:1433 --name sql1   -d mcr.microsoft.com/mssql/server:2017-latest
```

> **La contraseña debe seguir la política de contraseña predeterminada** de SQL Server, de lo contrario, el contenedor puede NO arrancar/configurar el servidor SQL y dejará de funcionar. De forma predeterminada, la contraseña debe tener al menos 8 caracteres y contener caracteres de tres de los siguientes cuatro conjuntos: letras mayúsculas, letras minúsculas, dígitos de la base 10 y símbolos. Puede examinar el registro de errores ejecutando el comando de registros de la ventana acoplable.
>
> De forma predeterminada, esto crea un contenedor con la edición de desarrollador de SQL Server 2017. El proceso para ejecutar ediciones de producción en contenedores es ligeramente diferente. Para obtener más información se puede acceder al siguiente enlace: [Ejecutar imágenes de contenedor de producción](https://docs.microsoft.com/en-us/sql/linux/sql-server-linux-configure-docker?view=sql-server-2017#production).

Pasamos a ejecutar el contenedor docker mediante docker run (la parte en rojo en una línea evidentemetne):

```
sudo docker run -e 'ACCEPT_EULA=Y' -e 'SA_PASSWORD=12345aA-bB' -p 1433:1433 --name sql1 -d mcr.microsoft.com/mssql/server:2017-latest-ubuntu

518fa80cb17d633fc4b6ddd24894005238538074c50d3d4dcb03e2c872f039a1
```

Y vemos que ya está arrancado:

```
docker ps -a

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
518fa80cb17d mcr.microsoft.com/mssql/server:2017-latest-ubuntu "/opt/mssql/bin/sqls…" 7 seconds ago Up 5 seconds 0.0.0.0:1433->1433/tcp sql1
```

Vemos con un simple nmap que la aplicación está a la escucha en nuestro linux con ip 192.168.1.50:

```
 nmap -A -T4 192.168.1.50 -p 1433

Starting Nmap 7.60 ( https://nmap.org ) at 2019-05-07 22:34 PDT
Nmap scan report for pc-261.home (192.168.1.50)
Host is up (0.00012s latency).

PORT STATE SERVICE VERSION
1433/tcp filtered ms-sql-s
```



También podemos acceder al contenedor desde bash:

```
 sudo docker exec -it sql1 "bash"
root@518fa80cb17d:/#
```

Y conectarnos vía comando sqlcmd:

```
root@518fa80cb17d:/# /opt/mssql-tools/bin/sqlcmd -S localhost -U SA -P '12345aA-bB'

1> SELECT Name from sys.Databases

2> GO
Name                                                                            
--------------------------------------------------------------------------------------------------------------------------------
master                                                                          
tempdb                                                                          
model                                                                           
msdb                                                                            

(4 rows affected)
```

Creamos una nueva base de datos

```
1> CREATE DATABASE TestDB
2> GO
1> SELECT Name from sys.Databases
2> GO
Name 
------
master 
tempdb 
model 
msdb 
TestDB
```

Para salir bastará con escribir exit dos veces, una para salir de sqlcmd y otra para volver a la bash normal:

```
1> exit

root@518fa80cb17d:/# exit

exit
root@mytcpip:~#
```





Si queremos parar y borrar el contenedor bastará con ejecutar las siguientes instrucciones:

```
root@mytcpip:~# docker stop sql1
sql1
root@mytcpip:~# docker rm sql1
sql1
root@mytcpip:~# docker ps -a

CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
```







