Generar una debug API Key para Google Maps Android en Windows

Hay dos tipos de certificados, el debug, que se genera automáticamente cuando se lanza un proyecto; se utiliza para aplicaciones de test o desarrollo, no para publicar en Google Play. Para una app que vaya a publicarse se utiliza el certificado release. En este apartado nos centraremos en la creación de una debug.

La API Key que obtendremos se puede usar con todas las aplicaciones creadas con el mismo certificado (es decir, a efectos prácticos, en el mismo ordenador), independientemente del nombre del package.

Para la creación de una reléase, podéis consultar la página oficial de Android en la que hemos basado este tutorial.

Para utilizar la API Key de debug

1) Localizamos el archivo keystore debug.keystore en C:\Users\<Usuario>\.android

debug.keystore

debug.keystore

2) Abrimos la consola (Inicio -> Ejecutar -> cmd) y lanzamos el siguiente comando:

keytool -list -v -keystore "C:\Users\<Usuario>\.android\debug.keystore" -alias androiddebugkey -storepass android -keypass android
cmd - comando para generar el SHA1

cmd – comando para generar el SHA1

3) Copiamos el SHA1 (haz click aquí para ver cómo copiar y pegar en la consola de windows) generado:

cmd - recuperando el SHA1

cmd – recuperando el SHA1

4) Vamos a la consola de desarrollador de Google y creamos un nuevo proyecto:

Google Developer Console - Create New Project

Google Developer Console – Create New Project

5) Vamos a APIs:

Google Developer Console - APIs

Google Developer Console – APIs

6) Y activamos Google Maps Android API v2 (una vez activada pasa arriba de la lista):

Google Developer Console - Maps Android v2

Google Developer Console – Maps Android v2

7) Hacemos click en credentials:

Google Developer Console - Credentials

Google Developer Console – Credentials

8) Hacemos click en create new key:

Google Developer Console - Create New Key

Google Developer Console – Create New Key

9) Seleccionamos Android Key

Google Developer Console - Android Key

Google Developer Console – Android Key

10) Pegamos nuestra clave en el text área que se nos ofrece y le unimos:

;<nombre del package>
Google Developer Console - Introducimos nuestro SHA1 junto con el package de nuestra app

Google Developer Console – Introducimos nuestro SHA1 junto con el package de nuestra app

11) Copiamos la API key y la pegamos en el manifest.xml

Google Developer Console - Copiamos la SHA1

Google Developer Console – Copiamos la SHA1

 

¡Y ya está! Si encontráis algo que comentar, bueno o malo, no dudéis en hacerlo, cualquier feedback es bien recibido!

 

Instalar Sublime Text 3

Este post es una pequeña introducción a la instalación y uso de Sublime Text 2. Podéis encontrar una exhaustiva y provechosa introducción en los vídeo tutoriales de Jeffrey Way.

Instalación

Ahora mismo la version functional es la 2..0.2, pero la versión 3 lleva en beta desde hace bastante tiempo y es ya generalmente la que se usa, de manera que empieza a ser la recomendable. Vamos a la página de downloads (http://www.sublimetext.com/3) y descargamos la versión adecuada (en nuestro caso Windows 64 bits).

Descargar Sublime text 2

Descargar Sublime text 2

Instalar el Package Control

El Package Control es ya un plugin indispensable. Se trata de un repositorio de packages (plugins) para Sublime, desde donde buscar un package e instalarlo es cuestión de segundos.

Para instalar Sunlime Package Control nos dirigimos a la página del proyecto (https://sublime.wbond.net/installation) y seleccionamos el texto relativo a la versión que utilizamos (por defecto ya está escogido Sublime 3)

Código del Package Control

Código del Package Control

A continuación copiamos el texto completo de la pestaña.
Abrimos la consola de Sublime Text 3 (View => Show Console).

Abrir consola de Sublime Text 2

Abrir consola de Sublime Text 2

Pegamos en la línea de comandos (la línea de abajo) el texto que hemos copiado y apretamos Enter.

Insertar código en la línea de consola

Insertar código en la línea de consola

Reiniciamos.

Y ya tenemos en CTRL+SHIFT+P Package (Preferences => Package Control)

Package Control Manager

Package Control Manager

 

Consejos varios

Open folder

Para poder trabajar en un proyecto, lo mejor es abrir una carpeta en vez de un archivo. Al abrir una carpeta podemos trabajar con esa carpeta en la side bar, además de ver los archivos abiertos.

Trabajar con folders

Trabajar con folders

Usar cursor multiple (multiple cursor)

Ponemos el cursos en la palabra que queramos cambiar y apretamos Ctrl+D para seleccionar la siguiente aparición de esa palabra o Alt + F3 para seleccionar todas las apariciones a la vez.
Para seleccionar diferentes lugares en el documento apretamos Shift + botón derecho (o el botón del medio) y arrastramos, o añadimos mediante Ctrl + click y quitamos mediante Alt + click.

Trabajar con multicursor

Trabajar con multicursor

Atajos de teclado

Para activar la paleta de commandos, desde donde tenemos acceso a todos los commandos disponibles en el programa: Ctrl + Shift + P.
Búscar y abrir un archivo: Ctrl + P
Para navegar por símbolos: Ctrl + R (útil especialmente en CSS y en funciones js)
Mezcla de ambos: Ctrl + P “nombre de archivo”@symbol

Personalizar atajos de teclado

Para personalizar los atajos de teclado podemos cambiar los existentes o crear los nuestros.

Personalizar atajos de teclado

Personalizar atajos de teclado

Plugins útiles

Una vez tenemos instalado el Package Manager Control, ya podemos instalar los plugins que queramos. Tan fácil como abrir el Package Manager Control…

Instalar Package

Instalar Package

…y seleccionamos el plugin que queramos. Recomendados muchos, he aquí unos pocos:

Color Picker (CTRL+C)
EMMET
Advanced new file
HTTP Request Response

La documentación de cada uno de los plugins está en sus respectivas carpetas, que pueden consultarse mediante Browse Packages:

Browse Packages

Browse Packages

 

Instalar plugins manualmente

Algunos plugins deben instalarse manualmente. Para ello os bajáis el plugin de su página y lo ponéis en vuestra carpeta de Packages (Preferences => Browse Packages). Recordad reinicar el Sublime Text 2.

Recordad que podéis encontrar una gran introducción en los vídeo tutoriales de Jeffrey Way.

Alojar un dominio en el vhost de Apache

Si tenemos un servidor Apache en red para mostrar nuestras webs, y tenemos más de una web para mostrar, lo mejor es configurar nuestro Apache para albergar diferentes webs. Para ello, debemos configurar el vhost.

En este pequeño tutorial trabajamos con una máquina gratuita de AWS con un CentOS.

Sigamos los siguientes pasos:

1) Creamos un directorio en nuestro /var/www para el nuevo dominio:

sudo mkdir -p /var/www/example.com/public_html

2) Si no hemos actualizado los permisos para interactuar con nuestro www, debemos hacerlo ahora. Podéis consultar nuestra guía sobre cómo crear un servidor Apache en una instancia de AWS.

3) Creamos un archivo index.html en ese directorio con relleno de prueba para efectuar el test.

sudo nano /var/www/example.com/public_html/index.html

4) Una vez guardado y creado, entramos en la configuración de Apache

sudo vi /etc/httpd/conf/httpd.conf

5) Vamos a la sección de Virtual Hosts al final de todo del documento.

6) Descometamos (le sacamos la almohadilla) la línea:

NameVirtualHost *:80

7) Descomentamos:

desde <VirtualHost *:80> hasta </VirtualHost>

8) Dentro de <VirtualHost *:80>:

  • En Document Root ponemos el directorio creado anteriormente: /var/www/example.com/public_html
  • En Server Name ponemos el nombre del dominio con www.
  • Creamos Server Alias y ponemos sin www
  • Creamos e-mails, logs, etc, recomendables aunque no necesarios

9) Abrimos de nuevo un <VirtualHost *:80> y repetimos el proceso para el resto de dominios que tengamos.

10) Guardar y salir

11) Reiniciamos el Apache

sudo service httpd restart

12) Debemos, por supuesto, cambiar las redirecciones y DNSs de nuestro parking de dominios. Siempre son diferentes, pero la esencia es la misma: aquí tenéis un buen resumen de cómo manejar los dns.

 

Como crear una instancia gratuita en Amazon Web Services (AWS)

¿Qué es una instancia de Amazon Web Service?

Una instancia es una máquina virtual con parámetros y capacidades definidas y variables que tenemos en la nube de Amazon. Es decir, tú compras un ordenador en la nube con x memoria RAM, x espacio de disco, x procesador, etc., que puedes ampliar en periodos de pico, disminuir o parar. Se paga al mes y por uso: tantos recursos usamos, tantos pagamos.

Para empezar lo mejor es la prueba gratis de un año con una instancia con mínimos recursos, que puede contratarse en la página de capa de uso gratuito de AWS. Para comparar los precios de un contrato, es bueno empezar por utilizar la calculadora de precios aproximados mensuales.

Nuestra primera instancia

Para empezar partiremos de nuestra primera instancia gratuita. Una vez dados de alta a partir del link anterior, vamos a nuestra consola principal, donde tenemos todas las posibilidades de la nube de Amazon, que son muchas y muy diversas, y vamos a nuestras EC2 o instancias elásticas virtuales.

Consola Principal de AWS

Una vez allí, empezamos a crear una instancia:

Creación de una instancia

Se abrirá un asistente de configuración. Importante: aseguráos de que señaláis que sólo queréis las opciones gratuitas:

Seleccionar las opciones gratuitas

Seleccionamos, de entre las opciones gratuitas, la que más nos convenga, CentOS, Ubuntu, Windows 2008 Server, etc. Nosotros escogemos la primera, Amazon Linux AMI con 64 bits, basada en CentOS:

Tipos de instancias

Al ser gratuita optamos a lo mínimo:

Opciones

Podemos lanzar ya la instancia, pero vamos a configurar más detalles o por lo menos a conocerlos:

Detalles de configuración

Examinamos los detalles de la instancia y cambiamos lo que conseideremos o con lo que queramos jugar (podemos borrar instancias y crear nuevas más tarde, de manera que podemos probar). Importante: algunas de las opciones superan la capa gratuita, fijáos en el mensaje Additional charges apply.

No seleccionar las opciones de pago

Es importante configurar los Grupos de Seguridad, que son los diversos grupos de Firewall para nuestras instancias:

Grupos de Seguridad

 En él tenemos el puerto principal para comunicarnos con nuestra instancia: el puerto 22 para el SSH:

Puerto 22

Si usaremos nuestra instancia como Servidor Web necesitaremos abrir el puerto 80; también podemos abrir el 443 para el HTTPS, etc.

Abrir puertos en Grupos de Seguridad

Una vez terminado, lanzamos nuestra instancia. Fijaos que antes de lanzarla nos van a preguntar por el par de claves para conectarnos mediante SSH.

Lanzar la nueva instancia

Podéis escoger un par creado anteriormente, si ya lo tenéis, o crear uno:

El par de claves pública-privada

Si creamos uno es importante seguir bien los pasos y guardar bien la clave privada que nos vamos a bajar como un fichero .pemEs importante guardarlo bien.

El fichero .pem

Una vez lanzada la instancia, pasarán unos momentos de inicialización y cuando veamos que han pasado los dos checks positivamente, ya tendremos nuestra instancia:

Instancia completada

Si seleccionamos la instancia, veremos en la parte inferior del panel todos los datos. Fijaos en la DNS pública, que es la que nos servirá para conectarnos mediante SSH.

DNS pública

Conectarnos a nuestra instancia desde Windows: Cygwin

Si trabajamos desde Linux no tenemos problema, ya que normalmente el cliente SSH está instalado. Si trabajamos desde Windows tenemos que instalarnos un cliente Linux para conectarnos con nuestro Linux mediante SSH. Hay bastantes, normalmente se utiliza Cygwin o PuTTY. Para nuestro ejemplo utilizaremos Cygwin.

Instalamos Cygwin, y, para establecer la conexión ssh con Cygwin vamos a

C:\cygwin\home\<usuario>\.ssh

Copiamos el fichero .pem descargado al crear nuestro par de claves y lo copiamos en ese directorio.

Abrimos cygwin y escribimos el siguiente comando:

ssh -i ./path/key_pair.pem ec2-user@public_dns_name

donde:

  • el path es .ssh/xxxxxx.pem
  • el usuario, en nuestro caso es ‘ec2-user’ (si la instancia es Ubuntu el usuario es ‘ubuntu’, etc.; consultad el usuario de vuestra instancia).
  • y la public_dns_name es la DNS pública que hemos señalado en el panel de datos de vuestra instancia.

Decimos que sí queremos continuar cuando nos avisa de que no tenemos esa dirección en nuestros hosts.

Y en la primera conexión

¡Y ya estamos!

Ya estamos en nuestra instancia

Primera actuación en nuestra instancia: ponerla al día

Lo primero que podemos hacer es asegurarnos de que tenemos todo el software al día mediante la instrucción

Sudo yum update –y (la y instala sin confirmación, lo que en este caso nos sirve)

Lo más probable es que veamos una importante cantidad de updates, lo cual es tranquilizador.

 

Recuperar contraseñas en Filezilla

Un problema que tenemos a menudo al trabajar con el cliente de Filezilla: por lo que sea, necesitamos una de las contraseñas de los sitios ftp que tenemos en la lista y no la recordamos; ¿cómo recuperar una de esas contraseñas? Muy sencillo, casi… demasiado.

Windows

Id a C:\Usuarios\<usuario>\AppData\Roaming\FileZilla\sitemanager.xml

MAC

Id a /users/<usuario>/.filezilla/sitemanager.xml 

En este archivo sitemanager.xml encontraréis todos los datos que lee el Filezilla, por lo menos hasta la versión 3.7.3.

Quizás demasiado fácil, ¿no os parece? Aquí podéis leer una interesante discusión sobre una propuesta de securizar estos datos en la página de Filezilla. En nuestro caso, por deciros mi opinión, en un lugar en el que pasan muchos becarios y colaboradores, este archivo es un bravo peligro. Por otra parte, como dicen en la discusión, una buena administración ya tiene eso en cuenta.

¿Qué os parece?

Cordova Error: please install android target 17 (the Android 4.2 sdk)

Este error surge cuando preparamos nuestro proyecto Cordova desde consola y no tenemos las APIs de Android que requiere nuestro proyecto. En el caso de nuestro micro-tutorial es el 4.2 (API 17, es decir android target 17), pero podría ser cualquiera.

Para solucionarlo debemos poner android en la misma consola y nos saldrá el Android SDK Manager (que encontraréis también en la instalación). Desde allí podremos instalar lo que nos haga falta.

Android SDK Tools

Android SDK Tools

Recordad que el Android SDK y el proyecto Cordova de Apache no son lo mismo, de manera que configurar una cosa no significa que la otra reaccione.

 

No me encuentra un comando que he incluido en el path

Este micro-tutorial está pensado para evitar algunos quebraderos de cabeza. A veces configuro el path de Windows con la ruta para un comando específico (léase node, o java) y resulta que no funciona. Miro y remiro el path, y ahí está la ruta, pero no funciona.

La última vez me pasó con la instalación de node.js. La instalación me la puso al final del path. El problema viene cuando hay alguna instalación antigua en el path, o equivalente. El sistema lee el path desde el principio al final, y se para si encuentra lo que busca. De manera que una mala instalación o una instalación antigua puede invalidar la última instalación, ya que normalmente el programa las pone al final.

¿Solución? Poner la ruta en cuestión al principio. Creedme, muchas veces éste es el problema.

Configuración del path

Configuración del path – Poned siempre la ruta al principio

Moraleja: al configurar un path, es una buena idea poner siempre la ruta al principio.

 

Un error común en la instalación de PhoneGap / Cordova

Si algo ha ido mal en la instalación y configuración de PhoenGap, puede que os salga una pantalla como esta:

Consola - el error más común
Consola – el error más común

 

Este error es el que aparece cuando una o más de las configuraciones creadas anteriormente (Java, Ant, Android SDK) no responde. Si os fijáis, el comando create es un .bat en la carpeta android\bin que contiene lo siguiente:

@ECHO OFF
IF NOT DEFINED JAVA_HOME GOTO MISSING
FOR %%X in (java.exe javac.exe ant.bat android.bat) do (
SET FOUND=%%~$PATH:X
IF NOT DEFINED FOUND GOTO MISSING
)
cscript “%~dp0\create.js” %*
GOTO END
:MISSING
ECHO Missing one of the following:
ECHO JDK: http://java.oracle.com
ECHO Android SDK: http://developer.android.com
ECHO Apache ant: http://ant.apache.org
EXIT /B 1
:END

Fijaos bien que está buscando la ejecución de los comandos java.exe, javac.exe, ant.bat y android.bat. En la consola id al directorio \android\bin y allí ejecutad uno a uno estos comandos; así podréis detectar donde está el error. Incluso si no aparece error, puede que haya algún paso que os habéis saltado. A veces puede haber alguna complicación extraordinaria.

 

Hibernate 4: una introducción y un ejemplo básico

Introducción

Hibernate es un Framework de persistencia de Java. En esencia, la persistencia es la pervivencia de información en memoria para trabajar con ella o para traspasarla a otro lugar.

En el caso de la programación orientada a objetos, los frameworks de persistencia como Hibernate abren una sesión para trabajar con ellos y o bien utilizarlos durante la ejecución del programa o bien pasarlos a base de datos. Hablamos, entonces, de que un objeto está persistido cuando éste está en la sesión de Hibernate.

En los frameworks de persistencia existe otro concepto clave: el de transacción. En la sesión de Hibernate se abre también normalmente una transacción, que es la que controla todos los pasos que hay que dar con los objetos y, caso de que exista un error o fallo en medio del proceso, hace rollback, es decir, deshace lo hecho para evitar que nada quede a medias. El entorno de sesión y la transacción hacen de los frameworks de persistencia algo muy útil para trabajar con objetos y bases de datos.

Ejemplo básico – introducción con Eclipse e Hibernate Tools

En este ejemplo vamos a utilizar Eclipse Kepler for Java EE Developer (se recomienda Kepler por su integración con Maven aquí tenéis una excelente introducción a Maven) y una de las varias herramientas de Hibernate para ayudarnos a trabajar con Eclipse: Hibernate Tools for Indigo. Esta herramienta nos ayudará a crear el archivo de configuración, el fichero reveng.xml, la consola, los hbm.xml a partir de la base de datos, etc.

Para trabajar con Hibernate necesitamos:

  • un archivo de configuración (hibernate.cfg.xml) con los datos de conexión a la base de datos y el mapeo de los archivos *.hbm.xml (los ficheros de mapeo entre las clases y la base de datos). También se pueden usar annotations, aunque nosotores usaremos mapeo XML
  • los pojos y su correspondientes archivos hmb.xml, donde mapeamos los objetos con la base de datos y establecemos las relaciones.
  • una (opcional) clase con la que generar sesiones y controlar transacciones. Si no la creamos, podemos generar sesiones y transacciones en el mismo DAO. Estableciendo una clase creamos un constructor estático que nos permite crear la conexión y hacer un singleton con una instancia única de la conexión.

El flujo de trabajo es el siguiente:

  • Hibernate espera recibir un objeto y sus objetos relacionados para efectuar una acción sobre él.
  • Una vez lo recibe, abre una sesión (generada por la sessionFactory y como singleton, se llena de los datos del fichero de configuración de Hibernate y genera las conexiones dinámicamente para cada transacción) con la información que contiene el fichero de configuración hibernate.cfg.xml (lee el fichero, carga la información y crea el método getSessionFactory, que crea una sesión en memoria RAM y la retorna; en la sesión se traen los objetos mapeados a la memoria RAM; cuando hago un select o un get los objetos van a parar a la sesión de hibernate (son persistidos)).
  • Inicia la transacción, hace lo que tenga que hacer con ese objeto, cierra la transacción y cierra la sesión.
  • Si la operación es compleja e implica a muchos objetos relacionados, si hay un error o fallo en el proceso se establece un rollback para eliminar cualquier acción efectuada durante la sesión.

Ejemplo básico – pasos

1)    Creamos un poryecto Maven con el siguiente pom.xml

2)    Creamos la base de datos con el siguiente script.sql

3)    Si no las tenemos, instalamos las Hibernate Tools (Help -> Eclipse Marketplace -> Hibernate Tools for Indigo)

4)    Creamos el fichero de configuración hibernate.cfg.xml. Para ello nos situamos en nuestro proyecto y con el botón derecho New -> Other -> Hibernate -> Hibernate Configuration File (cfg.xml). Escogemos su situación (normalmente en resources, siguiendo la lógica de Maven) y ponemos los datos de la conexión a la base de datos.

5)    Creamos la consola de configuración de Hibernate (que le servirá al plugin entre otras cosas para generar código) (No veremos que Eclipse haya añadido nada, ya que se trata de una herramienta interna del plugin de Hibernate Tools)

6)    Creamos el fichero reveng.xml, que nos permitirá la ingeniería inversa) New -> Other -> Hibernate -> Hibernate Reverse Engineering File (reveng.xml). Nos situamos sobre el directorio resorces, ratificamos y en la página de configuración escogemos la consola que yahemos creado, le damos a Refresh para ver las bbdd e incluimos las tablas a mapear.

7)    Generamos el código poniéndonos sobre el iconos de las Hibernate Tools y seleccionamos Hibernate Code Generations Configurations…

8)    Llenamos los datos e indicamos qué queremos generar. Es buena idea volver a generar el fichero de configuración, pues en él se incluirá el mapeo de los ficheros hmb.xml.

9)    Si creamos las clases nosotros, sí podemos crear los hmb.xml mediante las Hibernate Tools y luego cambiar algunas cosillas. Para ello New -> Other -> Hibernate -> Hibernate Mapping file (hbm.xml), añadimos el package donde hemos creado las clases, nos aseguramos de que so las clases crradas, y las generamos. Es buena idea tenerlas en el directorio resources, junto con los otros ficheros de configuración y mapeo.

10) Tendremos que hacer, quizás, algunos cambios. Por ejemplo en mi caso:

  • No pilla la relación n-n, de manera que en el fichero cliente.hbm.xml:
<set name="productos" table="PRODUCTO" inverse="false" lazy="true">
    <key>
        <column name="IDCLIENTE" />
    </key>
    <one-to-many class="com.hibernate.model.Producto" />
</set>

Pasa a ser:

<set name="productos" table="CLIENTEPRODUCTO" inverse="false" lazy="true">
    <key>
        <column name="IDCLIENTE" />
    </key>
    <many-to-many class="com.hibernate.model.Producto" />
</set>

También ponemos:

<list-index column="idCliente"></list-index>
  • En el fichero Correoelectronico.hbm.xml:
<many-to-one name="cliente" class="com.hibernate.model.Cliente" fetch="join">
    <column name="CLIENTE" />
</many-to-one>

Pasa a ser:

<many-to-one name="cliente" class="com.hibernate.model.Cliente" fetch="join">
    <column name="IDCLIENTE" />
</many-to-one>
  • En el fichero Producto.hbm.xml:
<set name="clientes" table="CLIENTE" inverse="false" lazy="true">
    <key>
        <column name="IDPRODUCTO" />
    </key>
    <one-to-many class="com.hibernate.model.Cliente" />
</set>

Pasa a ser:

<set name="clientes" table="CLIENTEPRODUCTO" inverse="false" lazy="true">
    <key>
        <column name="IDPRODUCTO" />
    </key>
    <many-to-many class="com.hibernate.model.Cliente" />
</set>

11) Añadamos también cascade=”all” en los set de cliente.hbm.cfg para evitar el error object references an unsaved transient instance – save the transient instance before flushing

12) IMPORTANTE: en correoelectronico, cliente, identity:

<generator class="assigned" />

Pasa a ser

<generator class="identity" />

para evitar problemas con las foreign keys.

13) En dirección pasa a ser

<generator class="foreign">
    <param name="property">cliente</param>
</generator>

14) Como hemos dicho, la sesión y las transacciones las controlaremos desde una clase específica del DAO. Creamos un package q contenga los dao y añadimos el siguiente archivo HibernateHelper.java, que ya analizaremos convenientenmenet. Basicamente lo que ahce es inicializar una favctor´ñia de sesiones si no está ya incializada, y alrecibir la orden de guardar coge una sesión nueva, abre una transacción, ejecuta el sabe del objeto que se la ha enviado y cierra la transacción y la sesión.

15) Para probarlo podríamos hacerlo mediante JUnit, como haremos con las sesiones, pero vamos a crear un main, que tenéis en main.java.

 

 

Abrir puertos en el Firewall de Windows 2008 Server R2

Para abrir los puertos de Windows 2008 Server R2 el primer paso (que no el único) es abrir los puertos en el Firewall. En el caso de que utilicéis el Firewall que Windows tiene instalado por defecto, estos son los pasos a seguir. No es difícil, pero algunos de sus detalles pueden resultar confusos.

1)    Abrid el Firewall de Windows con Seguridad Avanzada

Firewall de Windows con Seguridad Avanzada

Firewall de Windows con Seguridad Avanzada

 

2)    En la pantalla del Firewall, seleccionamos Reglas de Entrada. Por defecto los puertos están abiertos de salida y cerrados de entrada. En las reglas de entrada hay algunas reglas por defecto. Nosotros vamos a Añadir Nueva Regla.

Reglas de Entrada

Reglas de Entrada

 

3)    Podemos añadir diferentes tipos de reglas. Nosotros señalamos Puertos.

Puertos

Puertos

 

4)    Señalamos que se trata de una conexión TCP y señalamos el puerto específico que deseamos (o rango de puertos como señala el ejemplo).

TCP - Puerto o Rango de Puertos a abrir

TCP – Puerto o Rango de Puertos a abrir

 

5)    ¿Qué puede controlar la regla?

  • Permitir completamente la conexión
  • Permitir la conexión si es segura según parámetros específicos
  • Bloquear la conexión

Nosotros vamos a abrir el puerto, por lo tanto vamos a Permitir la conexión.

Permitir la conexión

Permitir la conexión

 

6)    Escogemos el entorno en el que esta regla se aplica. Si abrimos el puerto para una aplicación web, como Node, debemos marcar los tres.

Escogemos los tres entornos

Escogemos los tres entornos

 

7)    Ponemos un nombre y una descripción. Es una buena práctica poner una descripción para luego reconocer mejor nuestra regla entre todas.

Nombre y descripción

Nombre y descripción

 

8)    Nos aseguramos de que está en la lista y de que está activada (círculo verde).

Regla activa

Regla activa

 

Tenéis más información, cómo no, en Microsoft.