Todas las entradas de: pruebas

Activar ejecución de script en PowerShell

La ejecución de script en PowerShell esta bloqueado por defecto, ademas de la recomendación de bloquearlo en las directivas de grupo si estamos dentro de un directorio activo.Script en PowerShell

Pero en ocasiones nos vemos en la necesidad de ejecutar algun script en powershell. Como fue en mi caso activar el entrono virtual para desarrollar en Python. No suelo utilizar windows, pero las obligaciones son las que son.

Powershell nos ofrece varios comandos para configurar este tipo de configuraciones.

Estado de las politicas de ejecución

Para ver nuestra configuración respecto a la politica de ejecución de script en nuestro powershell podemos utlizar el comando

1
Get-ExecutionPolicy

La salida de este comando nos mostrara el nivel de restriccion en el que nos escontramos actualmente. El valor por defecto suele ser “Restricted”. No podemos ejecutar ningun tipo de de script .ps1.

Tipos de politicas de ejecución de PowerShell

Los tipos de restricciones que nos podemos encontrar son las siguientes.

RESTRICTED: Es la opción predetermida a partir de sistemas Windows 8 y Windows Server 2012. No permite la ejecución de ningun tipo de script.

ALLSIGNED: Podemos ejecutar, siempre y cuando, el script este firmado por una organización de confianza. Antes de la ejecuión nos pedira autorización.

REMOTESIGNED: Es la opción predeterminada en Windows Server 2012 R2. Podemos ejecutar script, tanto locales como remotos. Los descargados desde internet tendran que estar desbloqueados.

UNRESTRICTED: Podemos ejecutar cualquier tipo de script, tanto lo firmado como los que no lo estan. Alto riesgo de ejecutar script peligrosos.

BYPASS: No bloquea la ejecuación de ningun script, tampoco nos pìde confirmación. Este modulo esta pensado para los script que se ejecutan embebidos dentro de otras aplicaciones más grandes.

UNDEFINED: Sin ningun tipo de restricciones.

Como cambiar las policas de ejecución en PowerShell

Aunque tengamos establecida la politica predeterminada, podemos establecer otro tipo de politica global que mejor se ajuste a nuestras necesidades. Para hacer esto utilizaremos el comando

1
Set-ExecutionPolicy

Si ejecutamos el comando sin ningun tipo de parametro, este no pedira el tipo de politca que deseamos utilizar.

Para saltarnos este paso podemos establecer el tipo de politica que deseamos utlizar seguido del comando, o seguido del paramentro “-ExecutionPolicy”, por ejemplo

1
Set-ExecutionPolicy Unrestricted

o

1
Set-ExecutionPolicy -ExecutionPolicy Unrestricted

Pero en ocasiones las directivas establecidas en las politicas del dominio en el directorio activo, nos lo impide.

Ambitos en las directivas de ejecución

PowerShell nos estable varios ambitos de ejecución. Si por politicas en el directorio activo, estas bloque algun tipo, como es mi caso, el cambio global puede no estar permitido. Para saltar esta restrición podemos establecer el tipo de politica de ejecución ha algun ambito de ejecución en concreto.

Tipos de ambitos de policas de ejecuión

En PowerShell tenemos tres ambitos para ejecutar nuestro script.

PROCESS: La politica de ejecución se estable para la sesión actual. Al reiniciar se establecera de nuevo la politica establecida por defecto.

CURRENTUSER: Este ambito avarca al usuario actual. Se cambia en estado en la subclave que se encuentra en HKEY_CURRENT_USER que se encarga de almacenar la configuración del usuario actual.

LOCALMACHINE: Este ambito se aplica a la maquina local, cualquier usuario que se registra en la maquina afectada tendra la politica de ejecución que establezcamos.

Em mi caso el problema que me impedia cambiar la politica global es la restricción en las politicas del directorio activo para establecer el tipo en el ambito de LOCALMACHINE.

Podemos ver las configuraciones de los diferentes ambitos los podemos realizarar indicando el parametro -List al comando Get-ExecutionPolicy

1
Get-ExecutionPolicy -List

El comando de Set-ExecutionPolicy nos permite especificar en que ambito queremos interactuar.

Para ello ejecutaremos el comando de la siguiente forma Set-ExecutionPolicy -Scope Ambito_queremos_actuar tipo_politica, por ejemplo

1
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned

 

Instalar servidor NGINX, y configurar virtual host en Ubuntu 18.04

Entre la variedad de seServidor web nginx en ubuntu 18.04rvidores web para linux, el más habitual suele ser Apache. Pero hay uno que esta comiendole terreno. Este es NGINX.

Instalación del servidor web NGINX

Para instalar este servidor en un Ubuntu 18.04 es facil, solo tenemos que tirar de repositorio y lo tendremos instalado sin ningun problema.

1
2
sudo apt-get update
sudo apt-get install nginx

En cuanto termine, ya tendremos instalado nuestro servidor web en nuestro sistema bajo Ubuntu 18.04

Abrir los puertos en el firewall del Ubuntu 18.04

Una de las opciones que nos agrega la instalación de nginx, es añadir los diferentes modos de funcional el servidor web, al firewall que trae por defecto la distribución de Ubuntu.

1
sudo ufw app list

Para activar los puertos de nginx en el firewall solo tendremos que utilizar el nombre del metodo que deseamos activar.

Para el modo de “http”, le indicamos a firewall que queremos usar el metodo “Nginx HTTP”. Con esta opción abriremos el puerto 80 en el firewall.

1
sudo ufw allow 'Nginx HTTP'

Para activar el modo HTTPS, y abrir el puerto 443 para la conexión seguras, utilizaremos la opción ‘Nginx HTTPS’

1
sudo ufw allow 'Nginx HTTPS'

Configurar un virtual host en el nginx

La configuración de los virtual host en el servidor nginx, es muy parecida a la que utilizamos en el servidor apache. en el directorio de nginx (/etc/nginx), tenemos las mismas carpetas que encontramos en el apache (sites-avaliable, sites-enabled, modules-available, modules-enabled, etc). La unica diferencia que encontramos con respecto Apache, es que los enlace simbolicos, que en apache los creamos con a2ensite o a2dissite, etc. En el caso de nginx los tendremos que crear manualmente.

1
sudo ln -s /etc/nginx/sites-available/virtualhost.conf /etc/nginx/sites/enabled/

Crear el fichero de configuración del virtualhost

En la carpeta de /etc/nignx/sites-available/ tenemos un fichero con la configuración por defecto del servidor. Podemos usar este fichero como plantilla para nuestros virtual host.

1
sudo cp /etc/nginx/sites-available/default /etc/nginx/sites-available/virtualhost1.conf

Editamos el fichero que hemos creado, para personalizar la configuración de nuestro virtual host.

1
sudo nano /etc/nginx/sites-available/virtualhost1.conf

Una de las primeras lineas que nos encotramos son las siguientes

1
2
 listen 80 default_server;
listen [::]:80 default_server;

Lo primero que deberemos de hacer es eliminar “default_server”,  de las dos lineas. A no ser que queramos que este virtual host que estamos configurando sea el servidor por defecto. En ese caso tendremos que, o eliminar el enlace simbolico de “default” dentro de la carpeta de los sites activados (/etc/nginx/sites/enabled/). O eliminar esa opción del fichero “default”. Tener dos host configurados como servidor por defecto da un conflicto en el servidor web.

El siguiente parametro que tendremos que modificar es la linea

1
root /var/www/html;

Estableciendo la ruta donde queremos que apunte nuestro virtual host.

1
root /var/www/mi_virtual_host;

La siguiente linea que tendremos que modificar sera la de

1
server_name _;

En esta linea especificaremos el nombre del dominio que deseamos utilizar en el virtual host

1
server_name dominio.local www.dominio.local;

Pondremos todos los dominio que desemos que responda nuestro servidor web.

Para una configuración basica ya tendriamos nuestro vistual host configurado. Solo nos queda pulsar Ctrl+X, confirmar el guardado de los cambios en nuestro fichero, y salir del editor.

Verificación de la configuración del virtual host

Una vez que tengamos nuestro fichero de configuración creado, comprobamos que los hemos hecho todo correctamente usando el siguiente comando

1
sudo nginx -t

Si recibimos una respuesta parecida a esta

1
2
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Nuestra configuración es correcta, y esta listos para reiniciar el servidor web.

Si recibimos cualquier otro mensaje, con algo parecido a esto.

1
nginx: configuration file /etc/nginx/nginx.conf test failed

Tenemos algun fallo en la configuración de nuestro servidor. tendremos que revisar la configuración, centrandonos en el error que acompaña al mensaje.

Una vez que tengamos el ok por parte del servidor nginx, solo nos queda resetar el servidor para que carge la nueva condiguración.

1
sudo systemctl restart nginx.service

Una vez reseteado el servidor web, ya tenemos nuestro virtual host funcionando sin problemas.

Si queremos verificar si el servidor funciona correctamente, aparte de probar a cargar la pagina,. Podemos utilizar el siguiente comando

1
sudo systemctl status nginx.conf

Donde en la linea de “active” no tendra que mostrar el siguiente mensaje si todo esta funcionando correctamente.

1
Active: active (running) since Thu 2018-05-17 13:33:58 UTC; 1h 18min ago

Como siempre, si tienes cualquier duda o problema, nu dudes en escrbirnos un comentario.

 

Configurar replicas en nuestro servidor MongoDB

Establecer las replicas en nuestro servidor de bases de datos MongoDB

MongoDB nos permite establecer unas replicas, que en caso de percance en el servidor principal, tomara el control una de estas replicas.

El numero de servidores que una instalación de mongoDB, es decir, contado el servidor principal y sus replicas tiene que ser impar. Esto Configuración de replicas en MomgoDBes debido a que la replica que de valla a utilizar se realizar por “votación”, y el que tenga más del 50% por ciento de los votos, es el que ocupara el puesto de primero. Esto no lo tengo yo muy bien entendido.

Por ello la configuración más habitual en un sistema MongoDB suele ser de 3 servidores, el principal y las dos replicas.

Configuración de las replicas en nuestro servicio.

El configurar las replicas en nuestro servidor MongoDB es muy sencillo.

Lo primero que tenemos que hacer es crear las carpetas donde se alojaran los ficheros de las bases de datos.

Para esta prueba, vamos a crear las carpetas en el propio servidor donde tenemos nuestra instalación de MongoDB.

1
2
3
4
5
6
mkdir /datos
mkdir /datos/principal
mkdir /datos/replica1
mkdir /datos/replica2
mkdir /datos/logs
sudo chown -R mongodb:mongodb /datos

Ademas de crear las carpetas donde se alojaran los ficheros de las bases de datos de cada uno de los servidores, hemos establecido a mongodb el propietario de las misma.

El siguiente paso que nos queda, es la crear las instancias de los servidores.

Configuración del servicio principal

Para el servidor principal quedaría de la siguiente manera.

1
sudo -u mongodb mongod --dbpath /datos/principal --logpath /datos/logs/principal.log --replSet servidoresMongo --smallfiles --oplogSize 128 --port 27017 --fork

La primera observación hemos ejecuta el comando bajo el usuario “mongodb”, sudo -u mongodb. Si lo hiciésemos con sudo normal, estaríamos dándole los permisos de root al proceso, se puede hacer, pero no es recomendable.

Explicación de los parámetros:

  • –dbpath: ruta donde se va ha almacenar los ficheros de las bases de datos.
  • –logpath: ruta donde queremos que se cree el fichero de log del servidor.
  • –replSet: Nombre del sistema. Todos los sistemas que pertenezcan al mismo sistema tendrá que tener el mismo replSet.
  • –smallfiles: control de los tamaños de los ficheros que componen el sistema.
  • –oplogSize: tamaño de los ficheros de log.
  • –port: Puerto donde esta a la escucha el servidor.
  • –fork: No se bloquea la sesión que inicio el mongod.
Configuración de las replicas

Para establecer los procesos de las replicas ejecutaremos el mismo comando, cambiando los parámetros de –dbpath, –logpath y –port, a los valores propios de cada proceso:

Replica 1:

1
sudo -u mongodb mongod --dbpath /datos/replica1 --logpath /datos/logs/replica1.log --replSet servidoresMongo --smallfiles --oplogSize 128 --port 27018 --fork

Replica 2:

1
sudo -u mongodb mongod --dbpath /datos/replica2 --logpath /datos/logs/replica2.log --replSet servidoresMongo --smallfiles --oplogSize 128 --port 27019 --fork

Una vez establecido los procesos que van a controlar cada uno de los servicios, entramos en la consola de mongo para configurar el uso de las replicas.

1
mongo --port 27017

Y creamos una variable con este formato para establecer los miembros del sistema.

1
2
3
4
5
6
cfg = {"_id":"nombreSistema", "members":[
{"_id":0, "host":"direccion_servidor:puerto"},
{"_id":1, "host":"direccion_servidor:puerto"},
{"_id":2, "host":"direccion_servidor:puerto"}
]
}

Para nuestro ejemplo, y suponiendo que los estamos haciendo en el propio servidor quedaría de la siguiente forma:

1
2
3
4
5
6
cfg = {"_id":"servidoresMongo", "members":[
{"_id":0, "host":"localhost:27017"},
{"_id":1, "host":"localhost:27018"},
{"_id":2, "host":"localhost:27019"}
]
}

Con la variable que acabamos de crear vamos ha cargar la configuración de las replicas en la configuración de nuestro MongoDB

rs.initiate(cfg)

Si todo ha sido correcto, una de las lineas que nos aparecerá sera un:

{ “ok” : 1 }

Verificación de nuestra configuración

Para verificar que así a sido, podemos ejecutar el siguiente comando.

rs.status()

Este nos mostrara el estado de las replicas, si están funcionando correctamente.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
{
"set" : "nombreSistema",
"date" : ISODate("2018-04-12T16:27:39.682Z"),
"myState" : 1,
"term" : NumberLong(1),
"heartbeatIntervalMillis" : NumberLong(2000),
"optimes" : {
"lastCommittedOpTime" : {
"ts" : Timestamp(1523550459, 1),
"t" : NumberLong(1)
},
"readConcernMajorityOpTime" : {
"ts" : Timestamp(1523550459, 1),
"t" : NumberLong(1)
},
"appliedOpTime" : {
"ts" : Timestamp(1523550459, 1),
"t" : NumberLong(1)
},
"durableOpTime" : {
"ts" : Timestamp(1523550459, 1),
"t" : NumberLong(1)
}
},
"members" : [
{
"_id" : 0,
"name" : "localhost:27017",
"health" : 1,
"state" : 1,
"stateStr" : "PRIMARY",
"uptime" : 6786,
"optime" : {
"ts" : Timestamp(1523550459, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2018-04-12T16:27:39Z"),
"electionTime" : Timestamp(1523544257, 1),
"electionDate" : ISODate("2018-04-12T14:44:17Z"),
"configVersion" : 1,
"self" : true
},
{
"_id" : 1,
"name" : "localhost:27018",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 6213,
"optime" : {
"ts" : Timestamp(1523550449, 1),
"t" : NumberLong(1)
},
"optimeDurable" : {
"ts" : Timestamp(1523550449, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2018-04-12T16:27:29Z"),
"optimeDurableDate" : ISODate("2018-04-12T16:27:29Z"),
"lastHeartbeat" : ISODate("2018-04-12T16:27:38.545Z"),
"lastHeartbeatRecv" : ISODate("2018-04-12T16:27:39.322Z"),
"pingMs" : NumberLong(0),
"syncingTo" : "localhost:27017",
"configVersion" : 1
},
{
"_id" : 2,
"name" : "localhost:27019",
"health" : 1,
"state" : 2,
"stateStr" : "SECONDARY",
"uptime" : 6213,
"optime" : {
"ts" : Timestamp(1523550449, 1),
"t" : NumberLong(1)
},
"optimeDurable" : {
"ts" : Timestamp(1523550449, 1),
"t" : NumberLong(1)
},
"optimeDate" : ISODate("2018-04-12T16:27:29Z"),
"optimeDurableDate" : ISODate("2018-04-12T16:27:29Z"),
"lastHeartbeat" : ISODate("2018-04-12T16:27:38.545Z"),
"lastHeartbeatRecv" : ISODate("2018-04-12T16:27:39.321Z"),
"pingMs" : NumberLong(0),
"syncingTo" : "localhost:27017",
"configVersion" : 1
}
],
"ok" : 1,
"operationTime" : Timestamp(1523550459, 1),
"$clusterTime" : {
"clusterTime" : Timestamp(1523550459, 1),
"signature" : {
"hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
"keyId" : NumberLong(0)
}
}
}

Si obtenemos una respuesta parecida a la de arriba, es que nuestro sistema esta funcionando correctamente.

Como de costumbre al final de los post, ya sabéis, ante cualquier duda, pues un comentario 8-))))

Importar ficheros CSV a nuestra base de datos en MongoDB

Como importar datos en formato csv a nuestro servidor en MongoDB

CSV es un formato de archivo muy extendido para el intercambio de información. El formato de este es muy simple. La primera fila suele importar fichero csv a mongodbser el nombre de los campos, separados por comas. Las demás filas son los datos en si.

Para importar este tipo de archivos csv ha nuestro servidor de bases de base de datos usaremos el mismo comando que nos proporciona la empresa detrás de MongoDB para importar datos desde un fichero en formato json.

Comando mongoimport

Como ya explique en el otro post donde importamos los datos en formato josn a nuestro servidor MongoDB el comando que utilizaremos es el que MongoDB nos pone a disposición de estas tareas. Este comando es mongoimport. Este comando tiene el siguiente formato básico.

1
mongoimport --db baseDatos --collection coleccion --file fichero_a_importar --type csv

Si nuestro servidor esta instalado en local, escuchando en el puerto por defecto, es decir, el 27017. Y ademas no tiene credenciales de acceso, sera suficiente.

Explicacion del comando mongoimport

Con el parámetro “–db”,  o “-d”, establecemos el nombre donde vamos a importar los datos. No tiene por que existir. Por norma en mongodb, si la base de datos no existe automáticamente el servidor de base de datos no lo crea por nosotros.

El parámetro “–collection”, o “-c”,  estableceremos el nombre de la colección que va ha albergar los documentos que vamos ha importar. Como en el caso de la base de datos, si esta no existiera, el servidor de mongodb la crearlo por nosotros.

El parámetro siguiente, “–file”, establecemos el nombre del fichero en formato csv que vamos a importar.

El parámetro “–type csv” establecemos que el tipo de archivo que vamos ha importar esta en formato csv. En el anterior post, no utilizamos este parámetro, ya que el comando de mongoimport, si no lo indicamos, asume que vamos a utilizar el formato json.

Y en escenario básico, dando se las condiciones anteriores, esto sería suficiente.

Otro parámetros de mongoimport

Pero lo habitual no es tener este escenario idílico, tendremos que utilizar otro parámetros para establecer, tanto el host donde se encuentra el servidor, el puerto en el cual está a la escucha. Y el nombre de usuario y contraseña que necesitaremos para autentificarnos.

Lo parámetros necesarios para estas operaciones son los siguiente.

Para establecer el host del servidor utilizaremos el parámetro “–host” o en su versión abreviada “-h” seguido de la dirección del servidor.

Para el puerto el parámetro que necesitamos es “–port” seguido del puerto que utiliza el servidor de mongodb.

También podemos establecer el host y el puerto con el mismo parámetro host. Para ello lo podemos hacer de la siguiente formato.

1
mongoimport --host direccion_o_IP:puerto

o en formato abreviado

1
mongoimport -h direccion_o_IP:puerto

Para lo que se refiere al registro en el servidor, usaremos el parámetro “–username” o “-u” seguido del nombre de usuario que vamos a utilizar. Para establecer la contraseña usaremos el siguiente parámetro “–password” o en versión abreviada “-p”.

Ejemplo de uso de mongoimport

Un ejemplo de uso quedaría de esta forma.

1
mongoimport --db baseDatos --collection coleccion --type csv --host direccion_o_ip --port 23456 --username usuario --password contraseña --file ficheroImportar.csv

Y si todo lo hemos escrito correctamente, y no se ha producido ningún error, ya tendríamos nuestros datos importados a nuestro servidor de base de datos con MongoDB.

Si te has quedado con alguna duda, me puedes dejar un comentario.

Configurar interface de red en versiones de Ubuntu 17.10 o superiores

Configuración de la interface de red en Ubuntu 17.10

Desde la versión 17.10, Ubuntu ha activado por defecto en sistema “Netplan” para la configuración de los interfaces de red. Aunque en la versión 17.10 se ha activado como la opción de configuración de red por defecto. El sistema ya viene implementatado desde la versión 16.04.

Este sistema es totalmente distinto a lo que hasta ahora veniamos Configuración de redutilizando para la configuración de las tarjetas de red.

El primer cambio que nos encontramos, es la ubicación de los ficheros de configuración. Pasando de estar en /etc/network/interfaces a estar en /etc/netplan/01-netcfg.yaml.

Configuración de la interface

El formato de esta nueva versión es completamente diferente a la que normalmente veniamos usando en las versiones anteriores.

Una estructura basica del fichero 01-netcfg.yaml, seria la siguiente:

1
2
3
4
5
6
7
8
# This file describes the network interfaces available on your system
# For more information, see netplan(5).
network:
version: 2
renderer: networkd
ethernets:
enp0s3:
dhcp4: yes

Una de las cosas que hay que tener muy en cuenta es respetar las tabulaciones, si la establecemos mal, sera una de las causas que nos pueden probocar un error en la configuración.

El ejemplo muestra como seria una configuración por defecto para una interface que obtega la dirección ip desde una servidor de DHCP.

La configuración se divide en dos zonas, la primera con indicaciones para la herramienta Netplan. Y la segunda, con la configuración de las interfaces de red.

Debajo del paramentro “ethernets” pondremos la configuración de todas nuestas interfaces de red que tengamos instaladas en nuestro sistema.

Para realizar esta configuración los primeros que debemos de indicar sera, el nombre logico asignado a la tarjeta. En el caso del ejemplo “enp0s3”.

Debajo de el y con un nuevo nivel de tabulación pondremos la configuracion. En el caso del ejemplo, como esta configurada, para que obtega la dirección IP desde el servidor de DHCP. Solo tendremos que poner:

1
dhcp4: yes

Y ya tendriamos la configuración establecida.

Otras configuraciones

En el caso que queramos personalizar la dirección ip de la interface, utilizariamos los siguientes comandos:

  • addresses: Dirección que queremos establecer para la interface. Para establecer la mascara de red, se lo indicaremos mediante su longitud en la dirección ip. Ejemplo: 192.168.0.10/24. Pueder ver en esta entrada de la Wikipedia los valores utlizados.
  • gateway4: Dirección ip del gateway para la versión 4 del protocolo IP. Para establecer el gateway para la versión 6, solo tendriamos que cambiar en 4 por el 6, y establecer una dirección de tipo v6.
  • nameservers: bloque para establecer los servidores de dns que va ha usar la tarjeta de red. Para indicar la dirección utilizaremos el parametros addresses, al igual que la dirección IP, la acotaresmos entre corchetes, las direcciones IP de los servidores de DNS, las separaremos por comas.

Estos serian los paramentros basicos para establecer la dirección estatica para la tarjeta de red.

Ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
network:
version: 2
renderer: networkd
ethernets:
enp0s8:
dhcp4: yes
enp0s3:
dhcp4: no
addresses: [192.168.100.10/24]
gateway4: 192.168.100.1
nameservers:
addresses: [9.9.9.9, 8.8.8.8]

Si queremos establecer la configuración para más de una interface la podriamos a continución con el mismo formato.

Con esto ya tenemos nuestra tarjeta configurada.

Como de constumbre, cualquier duda comentario.

Importar datos en nuestra base de dsatos en MongoDB

Importar datos desde un fichero json a nuestro servidor de MongoDB

Cuando trabajamos con bases de datos, ya sea para pruebas o para iniciar una puesta en marcha en producción. Lo habitual es que tengamos que importar datos desde otro sistema.

El formato JSon es uno de los formatos de intercambio de datos que Importación datos a MongoDBmás popularidad tiene en la actualidad. Este formato nos permite una gran flexibilidad en el manejo de estos. Casi todos los lenguajes de programación, por no decir todos, en la actualidad cuenta con librerías para el manejo de este tipo de datos. Por lo que el manejo de estos se vuelve muy sencillo.

En el caso de MongoDB, no necesitamos utilizar ningún lenguaje de programación para importar un fichero en formato JSon a nuestra base de datos.

Dentro de la instalación de MongoDB podemos encontrar un comando que nos facilita y mucho esta tarea. Este comando es “mongoimport”

Ha este comando le tendremos que pasar una serie de parámetros para indicarle en que base de datos queremos guardas las colecciones, las tablas en el formato de bases de datos relacionales. El nombre de la colección donde queremos que se guarden nuestros documentos, los registros siguiendo la analogía con las bases de datos relaciones. Y por ultimo, el fichero en formato json donde se encuentran nuestros datos.

MongoDB nos facilita un fichero json con las ciudades de Estados Unidos para hacer pruebas. Vamos a usar este fichero para mostrar un ejemplo. El fichero lo podéis encontrar en la siguiente dirección: http://media.mongodb.org/zips.json. Lo descargamos y lo guardamos en nuestro sistema.

Una aclaración, este método es independiente del sistema donde tengamos instalado nuestro servidor MongoDB. Funciona tanto en Linux, Windows, o Mac. En este caso y que no sirva de precedente, las pruebas la he realizado con un windows 10, y con servidor Debian. Lo habitual es tener el servidor de MongoDB corriendo en un servidor Linux.

Importar los datos a nuestro servidor de MongoDB.

Una vez que ya tenemos nuestro fichero descargado vamos a ver como lo importamos.

1
mongoimport --db ciudadesdb --collection ciudades --drop --file zips.json --port 8080

Con el parámetro “–db” le indicamos que queremos guardar los datos en la siguiente base de datos. En este caso “ciudadesdb”.

Con el parámetro “–collection” le indicamos la colección, es decir, la tabla donde queremos guardar los datos. En este caso “ciudades”.

El parámetro “–drop” le indicar a mongoimport que descarte todos los datos que hubiese ya en la colección. Es decir, borraría todos los datos que tuviese la tabla antes de realizar la importación de los datos. Cuidado con este parámetro, si queremos añadir los nuevos datos a los ya existentes, no debemos incluir este parámetro.

El parámetro “–file” es donde le indicamos a mongoimport donde está el fichero en formato json con los datos que deseamos importar.

Y esto sería suficiente que nuestro servidor,

  1. Esta en el equipo local, es decir, está en “localhost”.
  2. El puerto que está a la escucha es el de por defecto de la instalación de MongoDB.
  3. Y además no tiene nombre de usuario ni contraseña para acceder a él.

Parámetros avanzados para mongoimport

Como en muchos de los casos no se va a dar alguna de estas opciones tendremos que utilizar alguno de los siguientes parámetros.

Para indicarle a mongoimport en qué dirección esta nuestro servidor usaremos el paramento “–host” y le indicaremos la dirección donde se encuentra nuestro servidor.

Para indicarle el puerto por que cual está a la escucha nuestro MongoDB utilizaremos el paramento “–port” y el puerto que hemos configurado.

Para autentificarnos en el servidor tendremos que utilizar los siguientes paramentos. Para indicarle el nombre de usuario que tenemos que usar usaremos el parámetro “–username” o en versión corta “-u” seguido del nombre de usuario que deseamos usar. Para indicarle la contraseña utilizaremos le parámetro “–password” o “-p” seguido de la contraseña deseada.

Con estos parámetros ya podremos indicar el servidor que deseamos usar, y el usuario de queremos utilizar.

Si queréis saber más parámetros que podéis utilizar para importar datos a nuestro servidor MongoDB utilizando el comando mongoimport tenéis más información en la página oficial en https://docs.mongodb.com/manual/reference/program/mongoimport/

Y esto sería todo, alguna duda, ya sabéis comentario al canto.

 

 

Instalar antivirus en servidor Linux

En muchas ocasiones necesitamos instalar un antivirus en nuestro servidor de ficheros bajo un sistemas Linux. Al tratarse de un sistema Linux, las opciones son un poco escasas.

ClamAV AntivirusLa mejor opción que podemos utilizar es instalar el antivirus ClamAV. Este antivirus es preparado para correr sin ningún problema en nuestro servidor de aplicaciones.

Instalar el antivirus ClamAV en nuestro servidor

Lo primero que debemos hacer antes de instalar ClamAv, o cualquier otro programa, es tener nuestro sistema actualizado. Esto lo podemos hacer con los siguientes comandos.

1
sudo apt-get update; sudo apt-get uprade -y

Una vez que ya tenemos actualizado nuestro sistema, pasamos ha instalar el antivirus.

1
sudo apt-get install clamav clamav-daemon -y

Con clamav instalamos el antivirus propiamente dicho. Con clamav-daemon instalamos el servicio que se ejecutara al inicio de nuestro servidor.

Actualizar la base de datos del ClamAV

Con los pasos anteriores hemos instalado el software del antivirus. El siguiente paso que tenemos que hacer, es actualizarla base de datos de firmas de los virus. Para ellos solo tenemos que ejecutar el siguiente comando.

1
sudo freshclam

En algunas ocasiones, al ejecutarse este comando, nos muestra un mensaje de error. Este error es que no puede tener acceso en exclusiva. Esto esta ocasionado, por que le programa de ClamAV tiene abierta ya la base de datos. Para resolver este problema solo tenemos que para ClamAV.

Paramos el servicio

1
sudo service clamav-freshclam stop

Volvemos a ejecutar el programa para actualizar la base de datos

1
sudo freshclam

Una vez que termina de actualizar la base de datos, volvemos a activar el servicio de ClamAV

1
sudo service clamav-fressclam start

Realizar un escaneo con ClamAV

Para realizar un escaneo están fácil como ejecutar el programa e indicarle el direcctoria que deseamos escanear.

1
sudo clamscan -r /directorio/scanear/

En este ejemplo usamos el parámetro “-r”. Este parámetro lo que hace un escaneo recursivo, es decir, escaneamos la carpeta indicada y todas las incluidas dentro.

Escanear y eliminar los virus encontrados

Para escáner y eliminar los virus que encontremos los haremos de la siguiente manera:

1
sudo clamscan --remove /direcorio_escanear/

Activar el antivirus ClamAV en el inicio

Para que nuestro sistema este protegido cada vez que iniciemos nuestro equipo tendremos que añadir al arranque, tanto el servicio de CalmAv, como el servicio que se encarga de tener la base de datos actualizada.

Activar servicio de ClamAv

1
sudo /etc/init.d/clamav-daemon start

Activar servicio para el gestor de la base de datos

1
sudo /etc/init.d/clamav-freshclam start

Con esto ya tendremos nuestros servidor de ficheros protegido ante los virus.

 

 

Como ocultar nuestra conexión mediante una VPN

En determinadas ocasiones tenemos que proteger nuestra conexión de miradas indiscretas, ya sea porque estamos conectados en una WiFi publica, un hotel, etc.

Normalmente para esto se suele recomendar el uso de una VPN. Pero si el servidor de vpn no esta bajo nuestro control podemos no tener esa seguridad deseada.

Proton servidor de VPN anónima

La empresa Proton, famosa por su servidor de correo gratuito y anónimo, a puesto en marcha un servicio de VPN. Esta nos garantiza que nuestra información no sera compartida con ningún gobierno/empresa, y que no habrá ningún log con nuestros datos.

Proton pone a nuestra disposición varios planes de conexión. Varios de pago con diferentes velocidades de conexión, país de donde saldrá nuestra conexión. navegación a través de TOR, numero de dispositivos, etc.

Pero también tiene un plan gratuito. Esta cuenta esta limitado al uso de un solo dispositivos, elección de solo 3 países de salida y velocidad baja, pero suficiente para un uso normal.

Crear una cuenta en ProtonVPN

Lo primero que tenemos que hacer es entrar en la pagina de ProtonVPN y seleccionar el plan que deseamos. Para esta prueba seleccionamos el “FREE”.

Registro en ProtonVPN
Registro en ProtonVPN

El siguiente paso para poder usar el servicio, no es más que una pagina de registro. Como en cualquier pagina de registro, metemos nuestro nombre se usuario, contraseña, cuenta de correo de verificación y poco más.

Registro en ProtonVPN
Registro en ProtonVPN

En el siguiente paso Proton nos enviara a nuestro correo un código de verificación, introducimos el código en la casilla y seguimos.

Obtener archivo de configuración de servidor VPN

Una vez registrados tenemos acceso al escritorio  de nuestra cuenta en ProtonVPN, en el tenemos un menú con varias opciones, acceso al escritorio (Dashboard), aquí no mostrara nuestro username (para entrar en la pagina de Proton), si tenemos cuenta de correo de ProtonMail y nuestro plan y si queremos registrarnos a otro.

La siguiente opción es la de “Cuenta” (Account), en esta opción nos mostrara nuestro VPN Login y VPN Password, estos son los datos de identificación cuando creemos nuestra conexión vpn en nuestro dispositivo.

Descarga de ProtonVPN
Descarga de ProtonVPN

En la opción de “Descargas” (Download), podremos descargar tanto el cliente de vpn, como los ficheros de configuración. En mi caso lo he instalado en un Ubuntu, al pulsar sobre el icono de Linux, se nos abre una nueva ventana con los pasos que deberemos de seguir para instalar el cliente de OpenVPN.

Configuración de ProtonVPN
Configuración de ProtonVPN

Una vez que tenemos el cliente de OpenVPN instalado. Nos desplazamos un poco hacia abajo y no aparecerá las opciones para seleccionar la plataforma en la que estamos corriendo, el protocolo que queremos usar, el protocolo recomendado es el de UDP, pero si nuestra navegación es muy lenta podemos elegir el de TCP.

La ultima opción que tenemos que elegir es el país por el que deseamos salir. En la versión “FREE” solo tenemos 3 países donde elegir, Japón, Holanda y EEUU. Pulsamos la opción de “Server Configs” y vamos a uno de esos países. Elegimos el servidor “XX-FREE#X” y descargamos el fichero.

Servidores ProtonVPN
Servidores ProtonVPN

También tenemos la opción de descargarlos todos. Nos desplazamos hasta el final de la pagina y pulsamos sobre “Download all configurations”. Nos descargara un fichero “zip” con todos los ficheros.

Crear conexión VPN en nuestro dispositivo

Para crear una conexión en Ubuntu, hay varias maneras, por entorno gráfico o por consola.

Cliente red Ubuntu
Cliente red Ubuntu

Para crear la conexión en entorno gráfico, vamos a opciones de red, Configuración de vpn. Agregar una vpn y seleccionamos la opción de “importar desde archivo”. Se nos abrirá una ventana donde seleccionaremos el archivo que nos hemos descargado.

Importar configuración ProtonVPN
Importar configuración ProtonVPN

Con esto ya tendremos nuestra conexión configurada, con su certificado y demás configuración. Solo falta para terminar la configuración, indicar nuestro OpenVPN Username y OpenVPN Password. Lo introducimos en las casillas de “Nombre de usuario” y “Contraseña” respectivamente.

Configuración cliente VPN
Configuración cliente VPN

Listo ya tenemos nuestra conexión de vpn con un servidor realmente anónimo y seguro creada. Para comprobarla solo tenemos que activarla, abrir la pagina de www.cualesmiip.com y comprobar cual es nuestra ip publica.

 

C Sharp y .Net Core con Linux

.Net Core permite la portabilidad de nuestras aplicaciones ha cualquier sistemas, ya sea Linux, OSx o Windows.

La nueva versión del framework .Net nos permite desarrollar nuestras aplicaciones y poder ejecutarlas en cualquier sistema.

.Net Core logo

Como en Linux, pudiendo compilar nuestro código en las distribuciones más populares, como RedHat, Fedora, Suse, CentOS, Oracle, Debian, Linux Mint, Ubuntu, etc. .En sistemas Linux solo podremos crear aplicaciones en 64 bits. Para sistemas de microsoft podemos crear aplicaciones, no solo para pc’s, donde podemos personalizar la compilación desde versiones 7 de windows, hasta la

ultima de windows 10, pero también podemos compilar nuestros códigos para la XBox, la Raspberry Pi 3, con Windows 10, tanto para versiones de 32 como de 64. Para sistemas de apple podemos compilar para las versiones 10 de OSx, en concreto para las versiones 10.10, 10.11 y 10.12, solo en 64 bits. También podemos hacer correr nuestros programas en Android, aunque para este ultimo no esta muy preparado.

Como instalar .Net Core en Ubuntu.

En mi caso la instalación del framework de .Net Core lo he realizado en mi sistema con Ubuntu 17.04. Para ello tenemos que agregar las fuentes donde se encuentra el framework. Para que nuestro Ubuntu nos reconozca estas fuentes como fuentes seguras, lo primero que debemos hacer es agregar las firmas de estas.

curl https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > microsoft.gpg
sudo mv microsoft.gpg /etc/apt/trusted.gpg.d/microsoft.gpg

Una vez que ya tenemos añadidas las firmas, añadimos la direccion del repositorio donde esta alojado el framework del .Net Core.

sudo sh -c 'echo "deb [arch=amd64] https://packages.microsoft.com/repos/microsoft-ubuntu-zesty-prod zesty main" > /etc/apt/sources.list.d/dotnetdev.list'

Este repositorio es para la versión 17.04 de Ubuntu, si necesitas instalar el framework en otra versión puedes ir a esta pagina ( https://www.microsoft.com/net/core#linuxubuntu ) para encontrar las direcciones para versiones anteriores de Ubuntu.

Una vez que tengamos el repositorio cargado, actualizamos las librerías de nuestro Ubuntu.

sudo apt-get update

E instalamos el framework de .Net Core.

sudo apt-get install dotnet-sdk-2.0.0

En este caso es la versión 2.0 del .Net Core, ultima versión a la fecha de escribir este post.

Llegados a este punto ya podemos desarrollar nuestra aplicación en C#. El framework nos proporciona una serie de comandos, tanto para crear unas plantillas que nos facilitara la creación de nuestras aplicaciones, como para la compilación o la publicación de la aplicación.

Crear un nuevo proyecto con .Net Core en C#

Para probar si todo funciona correctamente, podemos crear la típica aplicación de “Hola mundo”, para ellos solo tenemos que crear un proyecto de tipo “Console”.

mkdir Mi_Proyecto
cd Mi_Proyecto
dotnet new console

Esta crea en la carpeta que le indiquemos un proyecto en lenguaje C# para ejecutarse en la consola de Linux, o de cualquier otro sistema compatible.

Si estamos usando la versión 1.0 de .Net Core, después de crear el nuevo proyecto, del tipo que sea, tendremos que ejecutar el comando “dotnet restore” para restaurar el árbol de dependencias del proyecto. En el caso de estar utilizando la versión 2.0, esto no es necesario, ya que este proceso esta incluido en la ejecución del comando “dotnet new”.

Ejecutar el proyecto .Net Core

Para probar la aplicación podemos utilizar el comando de compilar y ejecutar nuestro.

dotnet run

Este comando compilara y ejecutara el proyecto que se encuentre en el directorio. Si queremos indicarle donde se encuentra el proyecto tendremos que utilizar le parámetro “-p” seguido de la ruta donde se encuentre nuestro proyecto.

dotnet run -p /Ruta/Donde/Esta/Nuestro/proyecto.csproj

 Publicar un proyecto en .Net Core

Para distribuir nuestro proyecto debemos crear el paquete con nuestro ejecutable y todas sus dependencias. Para esto debemos usar el comando “dotnet publish”. Este comando nos creara una carpeta con todos los ficheros necesarios para la distribucion de la aplicación

dotnet publish -c Relase -o /Ruta/Carpeta/Salida -r tipo_Sistema -p Ruta/Donde/Esta/El/Proyecto.csproj

Con el parametro “-c” le indicamos que utilice la configuración para crear un compilado utilizado el tipo “Release”. Si no se indica este paramentro, se utilizara por defecto “Debug”.

El parámetro “-o” le indicamos la carpeta donde queremos que nos cree el paquete. Si no indicamos este parámetro lo creara en una carpeta dentro de la propia del proyecto.

El parámetro “-r” le indicamos que “runtime” o RID se va utilizar para crear la distribución. En este punto es donde le indicamos bajo que sistema operativo queremos que se ejecute nuestra distribución. Si no indicamos este parámetro, el paquete que se cree sera para el sistema operativo bajo el que estemos ejecutando el programa.

Las diferentes opciones son las siguiente:

RID de Windows
  • Portátil
  • win-x86
  • win-x64

Windows 7/Windows Server 2008 R2

  • win7-x64
  • win7-x86

Windows 8/Windows Server 2012

  • win8-x64
  • win8-x86
  • win8-arm

Windows 8.1/Windows Server 2012 R2

  • win81-x64
  • win81-x86
  • win81-arm

Windows 10/Windows Server 2016

  • win10-x64
  • win10-x86
  • win10-arm
  • win10-arm64
RID de Linux

Portátil

  • linux-x64

CentOS

  • centos-x64
  • centos.7-x64

Debian

  • debian-x64
  • debian.8-x64

Fedora

  • fedora-x64
  • fedora.24-x64
  • fedora.25-x64 (.NET Core 2.0 o versiones posteriores)
  • fedora.26-x64 (.NET Core 2.0 o versiones posteriores)

Gentoo (.NET Core 2.0 o versiones posteriores)

  • gentoo-x64

openSUSE

  • opensuse-x64
  • opensuse.42.1-x64

Oracle Linux

  • ol-x64
  • ol.7-x64
  • ol.7.0-x64
  • ol.7.1-x64
  • ol.7.2-x64

Red Hat Enterprise Linux

  • rhel-x64
  • rhel.6-x64 (.NET Core 2.0 o versiones posterores)
  • rhel.7-x64
  • rhel.7.1-x64
  • rhel.7.2-x64
  • rhel.7.3-x64 (.NET Core 2.0 o versiones posteriores)
  • rhel.7.4-x64 (.NET Core 2.0 o versiones posteriores)

Tizen (.NET Core 2.0 o versiones posteriores)

  • tizen

Ubuntu

  • ubuntu-x64
  • ubuntu.14.04-x64
  • ubuntu.14.10-x64
  • ubuntu.15.04-x64
  • ubuntu.15.10-x64
  • ubuntu.16.04-x64
  • ubuntu.16.10-x64

Derivados de Ubuntu

  • linuxmint.17-x64
  • linuxmint.17.1-x64
  • linuxmint.17.2-x64
  • linuxmint.17.3-x64
  • linuxmint.18-x64
  • linuxmint.18.1-x64 (.NET Core 2.0 o versiones posteriores)
RID de OS X
  • osx-x64 (.NET Core 2.0 o versiones posteriores)
  • osx.10.10-x64
  • osx.10.11-x64
  • osx.10.12-x64 (.NET Core 1.1 o versiones posteriores)
RID de Android (.NET Core 2.0 o versiones posteriores)
  • android
  • android.21

 

Esto seria lo básico para poder desarrollar en .Net Core bajo Linux.

Para facilitar el desarrolo en .Net  hay varias extensiones para  los principales editores que los desarrollados solemos utilizar, como puede Atom, Brackets, Sublime Text, Emacs, Vim o Visual Studio Code.

Control de un servomotor con arduino

Para controlar un servomotor con arduino, este nos lo pone muy fácil. A la facilidad de uso de estos dispositivos, se suma el de disponer de una librería nativa en el propio IDE de arduino.

Que es un servomotor o servo?

Servomotor MG90Los servomotores son simples motores DC con una caja de engranajes para reducir la velocidad de giro de este, y sumado a una electrónica para el control de la posición.

Como todo en esta vida, los hay de diferentes tipos, fuerzas, tamaños y como no colores.

El precio de los servos varían desde poco más de 1€, se pueden encontrar en Aliexpress o Amazon, hasta de varios cientos de euros, para sistemas industriales.

Para el uso que normalmente se hace de ellos, tanto en robótica “domestica”, como para pequeños proyectos donde el coste del prototipo no queremos que se nos salga de madre, con los baratos nos es más que de sobra.

Servomotores más habituales.

El modelos más habitual en el montaje de pequeños robot, o brazos articulados el servo más habitual es el modelo SG90, también se le conoce como 9g, creo que porque su peso es ese. Este servomotor nos ofrece tanto una calidad más que aceptable para nuestros proyectos, como un precio muy contenido, este suele estar por los poco más de 1€. Este tiene una caga de engranajes de plástico, por lo que si nuestro proyecto va a necesitar que desarrolle mucha fuerce, sera mejor utilizar otro tipo de servomotor. El tamaño de este es muy contenido y la mayoría de chasis, ya sea de vehículos, robots o brazos articulados, suele venir diseñados para albergar este tipo de servos. Otro modelo muy utilizado es el MG90 de tamaño y forma idéntico al SG90, pero con la caja de engranajes en metal. Al tener los engranajes de metal del par de fuerza que puede aguantar es mayor.

Que necesito?

Para trabajar con un servo y arduino, los materiales que vamos ha necesitar son los siguientes.

Materiales usados

Arduino UNO Arduino UNO r3
Servomotor MG90

o

Servomotor SG90

protoboard Protoboard
cables_union Cables de conexión

Esquema de montaje de un servomotor controlado con Arduino.

El esquema de montaje de un servomotor controlado con arduino es muy simple. Los cables de los que dispone el servo son muy simples, un cable de color rojo, para el positivo, este suele estar alimentado entre 4,8v hasta los 7v. Por que si no tenemos muchos dispositivos conectados a nuestro arduino, lo podremos alimentar con el sin ningun problema. Cable de color negro, como es normal el negativo del servo, si alimentamos nuestro servo con una alimentación externa al arduino no debemos que olvidarnos de unir todos las masas del proyecto, para homogeneizar esta. Y por ultimo es el cable de color amarillo, este es el de control del servo. Este cable de control lo conectaremos a cualquier pin PWD de nuestro arduino.

Esquema de montaje.

Codificación del servomotor con arduino

Para programar el servo con muestro arduino no tiene mayor complejidad. El propio IDE de Arduino dispone de una librería para el control de estos aparatos. Solo tendremos que ir a la opción de “Programa” –> “Incluir libreria” –> “Servo” o directamente escribir en nuestro código.

#include <Servo.h>

Una vez agregada la librería, solo tenemos que crear un objeto el cual controlara nuestro servo.

Servo controlServo;

Lo siguiente que deberemos hacer sera indicarle a nuestro objeto, en que pin esta conectado nuestro servo, esta operación se hace mediante el comando attach, este comando tiene dos versiones. La versión simple, a la cual solo le pasaremos como parametro el numero del pin al cual tenemos conectado nuestro servomotor.

controlServo.attach(4);

Y la versión extendida, en esta versión, ademas de pasar el pin donde esta conectado el servo, tambien le pasaremos el valor mínimo y máximo de tamaño de la onda de control del servo.

controlServo.attach(4, 200, 2100);

En el 99,9% de los casos, con pasarle el pin donde esta conectado el servo en el arduino sera más que suficiente.

Si queremo “desenlazarnos” de el la librería Servo de Arduino nos ofrece la posibilidad de hacerlo mediante el comando detach(). Solo con llamarlo nos desconectaremos del servomotor.

controlServo.detach()

Para comprobar que estamos conectados a un servo, contamos con el siguiente comando attached(), este nos devolverá “True” si estamos conectados o “False” si no lo estamos.

if (controlServo.attached() == true)
  {
    Serial.print('Estamos conectados al servo');
  }
  else
  {
    controlServo.attach(4);
  }

Para poder situar el servo en el ángulo que deseemos utilizaremos el comando write(). Ha este comando le pasaremos como parámetro el angulo en el que queremos posicionar nuestro servo.

controlServo.write(90);

Si queremos saber en que posición se encuentro nuestro servo utilizaremos el comando read(). Este nos devuelve el angulo en el que se encuentra nuestro servomotor.

int posServo;
posServo = controlServo.read();

Y con estos simples comando tendremos un control absoluto sobre los servomotores que tengamos conectados a nuestro Arduino.

Ejemplo completo del uso de servomotores con arduino.

#include <Servo.h>

Servo controlServo;
int pinServo = 4;
int posServo = 0;

void setup() {
  // put your setup code here, to run once:
  
  // Paramentros de Servo.attach(pin, min, max)
  // pin -> pin donde esta conectado la señal de servo
  // min -> Valor minimo de la onda del servo
  // max -> Valor maximo de la onda del servo
  controlServo.attach(pinServo);
}

void loop() {
  // put your main code here, to run repeatedly:
  if (controlServo.attached() == false)
  {
    controlServo.attach(pinServo);
  }
  
  posServo = controlServo.read();
  if (posServo != 90)
  {
    // Posicionamos el servo en los 90 grados
    controlServo.write(90);
    // Esperamos 1 segundo
    delay(1000);
  }
  else
  {
    // Lo posicionamos en los 180 grados
    controlServo.write(180);
    // Volvemos a esperar otro segundo
    delay(1000);
  }

  controlServo.detach();
}

Si tienes alguna duda o sugerencia, no dudes en dejarnos tu comentario.