El Mundo de Ubuntu

Python es un lenguaje de script desarrollado por Guido van Rossum.
Podemos codificar empleando programación lineal, estructurada y orientada a objetos (tengamos en cuenta que esta última es la que se ha impuesto en la actualidad).
Se cuenta con intérpretes de Python en múltiples plataformas: Windows, Linux, Mac etc. Se pueden desarrollar aplicaciones de escritorio como aplicaciones web. Empresas como Google, Yahoo, Nasa etc. utilizan este lenguaje para sus desarrollos (actualmente el creador de Python Guido van Rossum trabaja para Google.)
Se puede ejecutar instrucciones de Python desde la línea de comando o creando archivos con extensión *.py. Cuando uno comienza a aprender este lenguaje la línea de comandos nos provee una retroalimentación del resultado en forma inmediata.
El objetivo de este tutorial es presentar en forma progresiva los conceptos fundamentales de este lenguaje y poder analizar los problemas resueltos y codificar los problemas propuestos en este mismo sitio, sin tener que instalar en un principio el Python en su equipo (o luego de instalado poder avanzar con el tutorial en cualquier máquina conectada a internet).

Subir nuestra aplicación Hola mundo a internet.
Si ya tenemos nuestra aplicación ejecutándose en forma correcta localmente:

http://localhost:8080

Ahora para que la puedan acceder todos en internet debemos seguir los siguientes pasos:

El primer paso es registrarnos en Google si todavía no lo hemos hecho para obtener una cuenta y esto lo podemos hacer desde aquí
Si ya dispone la cuenta suministrada por Google desde el panel de administración podemos crear una aplicación presionando el botón "Create an Application".
Debemos seleccionar un nombre para nuestra aplicación que correrá como un subdominio de appspot.com.
Seleccionado un nombre disponible (podemos comprobar disponibilidad presionando el botón "Check Availability") asignamos un título y aceptamos los términos del servicio. Ya estamos en condiciones de subir nuestra aplicación
Controlar que nuestro archivo app.yaml tiene una estructura similar a:

application: tutorialya
version: 1
runtime: python
api_version: 1

handlers:
- url: /.*
script: tutorialya.py

Del ejemplo anterior deberá modificar la propiedad de application con el nombre de aplicación que gestionó desde su panel de control del Google App Engine. Lo mismo pasa con la propiedad script.
Desde la línea de comandos del sistema operativo ejecutar el siguiente programa en Python que tiene por objetivo hacer el upload de todo nuestro proyecto a la cuenta que tenemos asignada en Google App Engine:

c:\Archivo de programa\Google\google_appengine>appcfg.py update tutorialya/

En ese momento se nos solicitará nuestro mail y clave.

Ya tenemos en el servidor almacenado nuestro sitio, solo nos falta llamarlo para verlo correr en la web.

http://tutorialya.appspot.com/

Recordar de remplazar el nombre tutorialya con el nombre con el que crearon su aplicación desde el panel del Google App Engine.
Recuperar el dato de un text (App Engine).
Realizaremos una aplicación que muestre un formulario con un control de tipo text y cuando se presione el botón submit mostraremos el dato ingresado en otra página.

import cgi
import wsgiref.handlers

from google.appengine.ext import webapp

class Formulario1(webapp.RequestHandler):
def get(self):
    self.response.out.write("""
<html>
<head></head>
<body>
<form method="post" action="procformulario1">
Ingrese su nombre:<input type="text" name="nombre" size="20"><br>
<input type="submit" value="Ok">
</form>
</body>
""")

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    self.response.out.write(cgi.escape(self.request.get('nombre')))
    self.response.out.write("</body></body>")



def main():
application = webapp.WSGIApplication([('/', Formulario1),
                                        ('/procformulario1', ProcFormulario1)],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

El programa se inicia al ser verdadera la condición:

if __name__ == '__main__':
main()

Los módulos son objetos y todos los módulos tienen un atributo llamado __name__. El valor del __name__ de un módulo depende de cómo esté usándolo. Si se importa el módulo, luego la propiedad __name__ es el nombre del fichero del módulo, sin el directorio de la ruta ni la extensión del archivo. Pero también puede ejecutar el módulo directamente como si fuera un programa, en cuyo caso __name__ tendrá un valor especial predefinido __main__.
El if se verifica como verdadero y llama a la función main().
En la función main debemos crear un objeto de la clase WSGIApplication y pasar como parámetro una lista con elementos de tipo tupla que asocian una URL y la clase que procesa dicha petición.
Cuando hacemos referencia a la raiz de nuestro sitio:

http://localhost:8080/

El servidor ejecuta Formulario1 según la tupla indicada con: ('/', Formulario1)
De forma similar cuando se presiona el botón submit del formulario se llama:

http://localhost:8080/procformulario1

y mediante la asociación ('/procformulario1', ProcFormulario1) se ejecutará el código de la clase ProcFormulario.
Todas las páginas de nuestro sitio deben ser mapeadas en la lista:

application = webapp.WSGIApplication([('/', Formulario1),
('/procformulario1', ProcFormulario1)],
debug=True)

El segundo parámetro del constructor de la clase WSGIApplication es el modo de ejecución, normalmente el parámetro debug lo inicializamos en true mientras estamos depurando nuestra aplicación, cuando la finalizamos y la subimos al servidor el parámetro debug le asignamos False.
La clase WSGIApplication se encuentra en el módulo webapp que se encuentra en el paquete google.appengine.ext:

from google.appengine.ext import webapp

La clase Formulario1 hereda de la clase RequestHandler que se encuentra en el paquete webapp. Para generar la página solo debemos reescribir el método get que será el que genere la página web. Para generar el contenido de la página llamamos al método write. La clase RequestHandler contiene un atributo llamado response y este un atributo out que es el que contiene el método write, es decir cada vez que queremos imprimir en la página debemos disponer el siguiente código:

self.response.out.write("Hola Mundo")

Si se trata de generar un bloque grande de HTML podemos utilizar la característica de Python de definir un String de varias líneas encerrándolas entre triple comillas:

self.response.out.write("""
<html>
<head></head>
<body>
<form method="post" action="procformulario1">
Ingrese su nombre:<input type="text" name="nombre" size="20"><br>
<input type="submit" value="Ok">
</form>
</body>
""")

Como vemos no es necesario escapar con el caracter '\' las comillas dobles cuando usamos triple comillas.
Podemos llamar tantas veces al método write como se necesite, todos los string se almacenan en un archivo de memoria que es el que se enviará al navegador que hizo la petición.
Una vez que la página que contiene el formulario se muestra en el navegador el operador ingresa el nombre y al presionar el botón submit el navegador procede a enviar el dato ingresado al servidor.
En la propiedad action del formulario hemos indicado quien procesará el dato en el servidor:

action="\procformulario1\"

Recordemos que tenemos mapeada dicha url :

application = webapp.WSGIApplication([('/', Formulario1),
('/procformulario1', ProcFormulario1)],
debug=True)

Es decir que la clase ProcFormulario1 recibe el dato. Esta clase también hereda de RequestHandler pero debe redefinir el método post. Luego procedemos de forma similar a la otra clase para crear una página en forma dinámica llamando al método write, con la salvedad que para recuperar el dato cargado en el formulario procedemos a llamar al método get del objeto request que contiene la clase:

class ProcFormulario1(webapp.RequestHandler):
def post(self):
    self.response.out.write("<html><head></head><body>")
    self.response.out.write(cgi.escape(self.request.get('nombre')))
    self.response.out.write("</body></body>")

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Errores como tratar de abrir un archivo que no existe, acceder a un elemento de una lista que no existe, dividir por cero etc. genera un error que hace que nuestro programa se detenga y no continúe su ejecución. Pero con Python podemos preveer estas situaciones y definir un algoritmo que se ejecutará exepcionalmente cuando ocurra dicho error.
Si ejecutamos el siguiente código el programa se detendrá informándonos que se produjo un error y no puede continuar:

y=0
x=10/y
print 'esta linea nunca se ejecuta'

Utilizando excepciones podemos capturar el error y continuar la ejecución del programa:

y=0
try:
x=10/y
except ZeroDivisionError:
print 'No existe la division por cero'
print 'Esta linea si se ejecuta'

La estructura try/except requiere que indiquemos el tipo de excepción a capturar, en este caso cuando se trata de dividir por cero Python genera una excepción llamada ZeroDivisionError. Para capturar dicha excepción debemos disponerla seguido de la palabra clave except.
Si se produce la excepción se ejecutan las instrucciones que dispongamos en las líneas siguientes al except.
Cuando se captura una excepción el programa no se detiene y continua con las intrucciones siguientes al bloque try/except.
Veamos otro ejemplo de intentar acceder a un elemento que no existe en una lista:

lista1=['juan','ana','carlos']
try:
print lista1[5]
except IndexError:
print 'Intenta acceder a un elemento no existente a la lista'

lista1 almacena 3 elementos y tratamos de acceder al de la posición 5. Python en este situación genera una excepción de tipo IndexError, como disponemos el acceso dentro de la contrucción try/except y captura el tipo de excepción IndexError el programa no se detiene y ejecuta la instrucción seguida de la línea except IndexError.
Un tema de aplicación muy común donde se utilizan las excepciones es con el tratamiento de archivos, hay muchas situaciones que pueden generar excepciones en estos casos como puede ser que no se pueda abrir un archivo porque no existe, no lo pueda crear porque la unidad de amacenamiento está llena, el archivo se encuentra bloqueado por otro programa etc.
El código para crear, grabar y leer un archivo capturando las excepciones queda de la siguiente manera:

def creartxt():
    try:
        archi=open('datos.txt','w')
        archi.close()
    except IOError:
        print 'No se pudo crear el archivo'

def grabartxt():
    try:
        archi=open('datos.txt','a')
        archi.write('Linea 1\n')
        archi.write('Linea 2\n')
        archi.write('Linea 3\n')
        archi.close()
    except IOError:
        print 'No se pudo abrir el archivo'

def leertxt():
    try:
       archi=open('noexiste.txt','r')
       linea=archi.readline()
       while linea!="":
           print linea
           linea=archi.readline()
       archi.close()
    except IOError:
        print 'El archivo no existe'

creartxt()
grabartxt()
leertxt()

La excepción cumple un doble cometido en estas situaciones, primero mostramos mensajes que nosotros definimos y no los que Python muestra por defecto cuando se genera un error y por otro lado podemos continuar con la ejecución de nuestro algoritmo sin que se detenga.
Podemos disponer varios capturas de excepciones para un bloque try:

lista1=['juan','ana','carlos']
try:
    print lista1[0]
    z=10/0
except IndexError:
    print 'Intenta acceder a un elemento no existente a la lista'
except ZeroDivisionError:
    print 'Division por cero no permitida'

En este bloque try capturamos las excepciones de tipo: IndexError y ZeroDivisionError. Como podemos ver la que se dispara es la de ZeroDivisionError. Pero podemos generar el otro tipo de excepción modificando la línea de impresión del elemento de la lista:

print lista1[5]

Si hacemos este cambio se ejecuta la sección seguida a 'except IndexError:'. Una vez disparada dicha excepción no continua con las instrucciones del bloque del try, es decir no generará la excepción de división por cero, pero si continuará con el flujo del algoritmo.
Si no queremos tratar los errores en forma independiente podemos agrupar excepciones:

lista1=['juan','ana','carlos']
try:
    print lista1[0]
    z=10/0
except (IndexError,ZeroDivisionError):
    print 'Se produjo un error'

Debemos indicar entre paréntesis todas las excepciones a capturar y como se procede con ellas, en este caso solo se muestra un mensaje 'Se produjo un error'.
Otra parte opcional de un bloque try es la del else. Este bloque se ejecuta si no se produce la excepción:

lista1=['juan','ana','carlos']
try:
    print lista1[0]
    z=10/5
except (IndexError,ZeroDivisionError):
    print 'Se produjo un error'
else:
    print z

Este programa muestra el primer elemento de la lista, luego procede a inicializar la variable z con el valor 10/5 y seguidamente ejecuta la sección del else ya que no se a generado excepciones.
Podemos tratar de imprimir una componente que no exista de la lista y veremos que no se ejecuta el bloque del else.
Hemos visto que podemos capturar distintas excepciones en forma independiente:

except IndexError:
print 'Intenta acceder a un elemento no existente a la lista'
except ZeroDivisionError:
print 'Division por cero no permitida'

En forma conjunta:

except (IndexError,ZeroDivisionError):
print 'Se produjo un error'

Inclusive Python nos permite disponer un bloque try except para la captura de cualquier tipo de excepción (si bien esto no es lo más recomendable ya que es difícil emprender una acción para todos los tipos de errores que pueden generarse):

lista1=['juan','ana','carlos']
try:
    print lista1[0]
    z=10/0
except:
    print 'Se produjo un error'

Otra sección que puede tener un bloque try except es finally.
finally permite disponer un bloque de código que se ejecutará siempre, indistintamente se produzca o no la excepción. El objetivo de esta sección es generalmente utilizado para liberar recursos como puede ser cerrar la conexión con una base de datos o cerrar un archivo.

try:
    z=10/0
    print 'Esto no se ejecuta'
except:
    print 'Se produjo un error'
finally:
    print 'Siempre se ejecuta'

Google App Engine utilizando Python.

El servicio de Google App Engine nos permite obtener una cuenta para crear nuestras aplicaciones web utilizando los servidores y tecnología de Google. Y como ventaja después de haber estudiado Python Google App Engine nos facilita crear un sitio utilizando como lenguaje de servidor el Python.
Actualmente nos suministra 500 MB para el almacenamiento de nuestras páginas y base de datos, todo esto en forma gratuita.

El primer paso es registrarnos en Google para obtener una cuenta y esto lo podemos hacer desde aquí
Si tarda un poco la asignación de la cuenta no es tan importante ya que todo el desarrollo lo hacemos en forma local en nuestro equipo. Finalizado el proyecto lo debemos cargar en los servidores de Google.
Para trabajar en forma local debemos tener instalado el lenguaje Python en su versión 2.5 o superior.
También tenemos que tener instalado el kid de desarrollo que nos provee Google y ejecuta nuestra aplicación en forma local, podemos descargar la última actualización del mismo desde aquí.

Luego de instalar el Python 2.5 o superior debemos proceder a instalar el kid de desarrollo que nos provee Google. Cuando lo instalamos nos sugiere donde se instala el software (podemos dejar el que nos propone por defecto): c:\Archivo de programa\Google\google_appengine\
Ya tenemos todo para comenzar a experimentar con Python y el framework que nos provee Google para el desarrollo de aplicaciones web.
Si ya dispone la cuenta suministrada por Google desde el panel de administración podemos crear una aplicación presionando el botón "Create an Application".
Debemos seleccionar un nombre para nuestra aplicación que correrá como un subdominio de appspot.com, como podrán comprobar muchos de los nombres más comunes ya han sido tomados por otros usuarios.
Seleccionado un nombre disponible (podemos comprobar disponibilidad presionando el botón "Check Availability") asignamos un título y aceptamos los términos del servicio. Ya estamos en condiciones de subir nuestra aplicación (tengamos en cuenta que todavía no hemos desarrollado ni el 'Hola Mundo').
Hola mundo con Google App Engine.
Primero debemos crear un directorio donde se instaló el Google App Engine, normalmente en: c:\Archivo de programa\Google\google_appengine\
Este nombre debe coincidir con el que obtuvimos desde el panel de control de nuestra cuenta de Google App Engine (yo tomaré como nombre tutorialya)
Para utilizar los servidores de Google deberemos crear un archivo de configuración llamado app.yaml y que deberemos localizar en el directorio que acabamos de crear.
El archivo app.yaml tiene una estructura similar a:

application: tutorialya
version: 1
runtime: python
api_version: 1

handlers:
- url: /.*
script: tutorialya.py

Del ejemplo anterior deberá modificar la propiedad de application con el nombre de aplicación que gestionó desde su panel de control del Google App Engine. Lo mismo pasa con la propiedad script.
Ahora que tenemos nuestro directorio donde se alojará nuestro sitio en forma local y el archivo de configuración app.yaml debemos crear el archivo Python principal y lo llamaremos igual que el nombre de la carpeta y con extensión *.py y debe coincidir con la propiedad script del archivo app.yaml (en mi caso yo lo llamé tutorialya.py).
Para codificar nuestra aplicación Google creó un framework propio llamado webapp y que se instala automáticamente con nuestra aplicación.
Luego nuestra aplicación mínima utilizando dicho framework es:

import wsgiref.handlers

from google.appengine.ext import webapp

class HolaMundo(webapp.RequestHandler):
def get(self):
    self.response.out.write('<html><head></head>')
    self.response.out.write('<body>')
    self.response.out.write('<h1>Hola Mundo</h1>')
    self.response.out.write('</body>')

def main():
application = webapp.WSGIApplication([('/', HolaMundo)],
                                       debug=True)
wsgiref.handlers.CGIHandler().run(application)

if __name__ == '__main__':
main()

Después nos detendremos en la forma de codificar utilizando este framework, por ahora solo nos interesa ver aparecer el 'Hola mundo' en el navegador.
Ya tenemos codificado el archivo *.yaml y *.py, ahora queda iniciar nuestro servidor y peticionar la página.
Como servidor web no utilizaremos el Apache, sino un servidor creado con Python que viene incluido con el Google App Engine. Para activar este servidor debemos ir a la línea de comandos de nuestro sistema operativo hasta la carpeta (c:\Archivo de programa\Google\google_appengine\) y desde allí arrancar el servidor indicando el nombre de nuestra aplicación:

c:\Archivo de programa\Google\google_appengine>dev_appserver.py tutorialya/

Tener en cuenta de pasar como parámetro al programa dev_appserver.py el nombre de la carpeta que hemos creado para nuestro proyecto (en mi caso la llamé tutorialya)
Si tenemos correctamente creado el archivo *.yaml deberá mostrar un mensaje que el servidor web está esperando peticiones en el puerto 8080. Luego desde el navegador debemos llamar nuestra aplicación con la siguiente sintaxis:

http://localhost:8080

Si codificamos correctamente la aplicación deberemos tener el mensaje 'Hola Mundo'.

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

Creación, carga y lectura de archivos de texto.
Python cuenta con una clase llamada file que nos permite crear, escribir y leer datos de un archivo de texto.
Para crear un objeto de la clase file debemos utilizar la función open. Cuando llamamos a dicha función le pasamos como primer parámetro el nombre del archivo de texto y el modo de apertura del mismo:

open(nombre del archivo,modo)

Si el archivo de texto se encuentra en la misma carpeta que nuestro programa no necesitamos indicar el path (camino). Los modos de apertura del archivo de texto pueden ser:

'r' Abre el archivo para lectura (debe existir el archivo)
'w' Crea el archivo y lo abre para escribir
'a' Abre el archivo para escribir. Se crea si el archivo no existe. Solo podemos agregar datos al final

Creación de un archivo de texto.
El siguiente algoritmo crea en disco un archivo de texto llamado 'datos.txt' y no graba datos. Si queremos luego de ejecutar el programa podemos verificar la existencia del archivo en la misma carpeta donde almacenamos nuestro programa.
Cuando lo grabamos el archivo fuente en Python debemos darle un nombre al programa (por ejemplo texto1.py)

def creaciontxt():
archi=open('datos.txt','w')
archi.close()

creaciontxt()

Creamos una función llamada creaciontxt donde primero llamamos a la función open pasando como parámetros el nombre del archivo de texto a crear y el modo de apertura ('w')
La función open retorna la referencia del objeto file. Luego llamamos al método close de la clase file. Si luego queremos ver si se a creado el archivo de textos podemos hacerlo desde algun explorador de archivos, en la carpeta donde se encuentra nuestro programa en Python veremos un archivo llamado 'datos.txt' que tiene un tamaño de 0 bytes.
Grabación de líneas en el archivo de texto.

La función creartxt es similar al ejemplo anterior, y la función grabartxt tiene por objetivo abrir el archivo en modo de agregado. Cada vez que grabamos un string en el archivo de texto insertamos un salto de línea '\n'. Finalmente liberamos el archivo llamando al método close.
Para ver el contenido de nuestro archivo de texto debemos utilizar un editor de texto (bloc de notas o el mismo entorno del Idle nos puede servir para ver el contenido de un archivo txt)
Lectura línea a línea de un archivo de texto.
La clase file tiene un método llamado readline() que retorna toda una línea del archivo de texto y deja posicionado el puntero de archivo en la siguiente línea. Cuando llega al final del archivo readline retorna un string vacío.

def creartxt():
    archi=open('datos.txt','w')
    archi.close()

def grabartxt():
    archi=open('datos.txt','a')
    archi.write('Linea 1\n')
    archi.write('Linea 2\n')
    archi.write('Linea 3\n')
    archi.close()

def leertxt():
    archi=open('datos.txt','r')
    linea=archi.readline()
    while linea!="":
        print linea
        linea=archi.readline()
     archi.close()

creartxt()
grabartxt()
leertxt()

Luego de de abrir el archivo para lectura procedemos a leer la primer línea:

archi=open('datos.txt','r')
linea=archi.readline()

El while se repite mientras el método readline() no retorne un string vacío. Dentro del while procedemos a imprimir la línea que acabamos de leer y leemos la siguiente (el método readline() retorna el contenido de toda la línea inclusive el salto de línea \n):

while linea!="":
print linea
linea=archi.readline()

Podemos leer todo el contenido de un archivo de texto y almacenarlo en una lista (esto tiene sentido si el archivo de texto no es muy grande):

def creartxt():
    archi=open('datos.txt','w')
    archi.close()

def grabartxt():
    archi=open('datos.txt','a')
    archi.write('Linea 1\n')
    archi.write('Linea 2\n')
    archi.write('Linea 3\n')
    archi.close()

def leertxtenlista():
    archi=open('datos.txt','r')
    lineas=archi.readlines()
    print lineas
    archi.close()

creartxt()
grabartxt()
leertxtenlista()

Utilizamos el método readlines() en lugar de readline(). El método readlines() retorna una lista con cada línea del archivo de texto.
Recordemos que podemos procesar luego cada elemento de la lista recorriéndola con una estructura repetitiva:

def leertxtenlista():
    archi=open('datos.txt','r')
    lineas=archi.readlines()
    for li in lineas:
        print li
    archi.close()

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Guias y Tutoriales

El comando unix dig (domain information groper), con el permiso de nslookup, es una de las mejores opciones a la hora de hacer troubleshooting o debug de problemas DNS.
Vamos a ver unos cuantos ejemplos de algunas las posibilidades que nos ofrece.
Como siempre podrán encontrar más información en la página man del comando o la ayuda:

$ man dig
$ dig -h

Ejecución sin argumentos.
.Cuando ejecutamos el comando dig sin argumentos se realiza una consulta de los NS (Name Servers) raíz o root servers “.”. Cara al troubleshooting o debug no suele ser de mucha utilidad:

Dominio como argumento.
La forma más común y simple de ejecutar dig. En este caso pasamos como argumento el dominio a consultar. Cuando no se especifica nada se consulta siempre el registro A del dominio.
Al no especificar tampoco los servidores DNS contra los que hacer la consulta se utilizan los especificados en nuestra conexión (/etc/resolv.conf). Debemos prestar especial importancia a la sección ANSWER SECTION, ya que muestra el resultado de nuestra consulta:

Dominio como argumento y usando un name server específico.
El comando anterior usaba el DNS local especificado en /etc/resolv.conf (127.0.0.1) para solicitar el registro A del dominio, en este caso vamos a hacer la consulta contra un NS externo, el de google por ejemplo (8.8.8.8). Se indica con la IP/nombre del servidor precedida de @.
Se puede ver en la sección final como se especifica el servidor que utilizamos para la query (negrita). La respuesta debería ser la misma que los servidores autoritativos del dominio, en caso contrario podría haber envenenamiento DNS, DNS spoofing…:

Especificar el registro (A, NS, MX, CNAME…) a consultar.
Como decía antes, por defecto se consulta el registro A del dominio, pero podemos especificar el tipo de registro que queramos (ANY, NS, A, MX, SIG,SOA…):

Consultar todos los registros de la zona DNS.
En lugar de especificar el tipo de registro a mostrar (A, MX, CNAME, AAAA…) podemos decir directamente que consulte todos los que se sirven en la zona DNS del dominio con el parámetero ANY:

Hacer debug con el parámetro trace.
El parámetro “+trace” es muy útil para hacer debug ante problemas de resolución DNS ya que permite ver la traza y saltos de la petición hasta que llega al servidor autoritativo que ofrece la respuesta del registro:

Para realizar consultas de reverse DNS tenemos el parámetro -x:

Si te ha gustado el artículo inscribete al feed clicando en la imagen más abajo para tenerte siempre actualizado sobre los nuevos contenidos del blog:

Sistema