A lo largo de este tutorial, resolveremos las limitaciones habituales que imponen los módems de los proveedores de internet (ISP) mediante la implementación de un resolvedor recursivo propio (Unbound), un túnel VPN seguro (Tailscale) y la protección física de nuestra tarjeta MicroSD mediante Log2Ram.

Requisitos de Hardware y Almacenamiento

Para garantizar la durabilidad y el rendimiento 24/7 de este servidor, las especificaciones recomendadas son:

• Dispositivo: Raspberry Pi 3 (B o 3B+) o superior.
• Almacenamiento: Tarjeta MicroSD SanDisk Ultra de 64 GB (modelo SDSQUNS-064G) o equivalente UHS-I / Clase 10. Al contar con una capacidad de 64 GB, el sistema distribuye las escrituras de manera uniforme uniformando el desgaste físico (wear leveling).
• Alimentación Eléctrica: Fuente o cargador de 5.1V y 2.5A con cables de cobre gruesos (20 AWG o 18 AWG) de menos de 1 metro. Evitá los cables finos tradicionales de telefonía para eludir errores de bajo voltaje (undervoltage detected).

1⃣ Grabado de la Imagen y Configuración Inicial (Bypass de Cloud-init)

A partir de las imágenes de desarrollo de Raspberry Pi OS Trixie, la fundación eliminó el soporte para habilitar el SSH mediante el clásico archivo vacío ssh. Ahora integra de forma nativa Cloud-init, el cual ignora configuraciones tradicionales si no se le suministran archivos YAML estructurales estrictos.

Flasheo Base

Descargá la imagen oficial de desarrollo (arm64-lite) y clonala directamente en tu tarjeta desde tu PC mediante la terminal:

bash

sudo umount /dev/mmcblk0*
xz -dc 2026-06-18-raspios-trixie-arm64-lite.img.xz | sudo dd of=/dev/mmcblk0 bs=4M status=progress conv=fsync

Configuración del Puerto 22 y Credenciales para Trixie

Volvé a conectar la tarjeta a tu PC y ubicate en la raíz de la partición de arranque (usualmente montada en /run/media/usuario/bootfs/). Generá tu contraseña cifrada con el comando openssl passwd -6 y creá exactamente estos dos archivos:

Archivo user-data (YAML Estricto con comillas simples):

yaml

#cloud-config
ssh_pwauth: true
users:
  - name: 'usuario'
    groups: ['sudo', 'netdev']
    shell: '/bin/bash'
    lock_passwd: false
    passwd: '$6$cadenalargaencriptada...'
ssh:
  install_redirect: false

Archivo ssh (Disparador por redundancia):

bash

sudo touch /run/media/usuario/bootfs/ssh

Expulsá la tarjeta limpiamente (sudo sync), colocala en tu Raspberry Pi 3 y encendela. Esperá unos 3 minutos a que inicialice por primera vez. Localizá su IP en tu red e ingresá de forma nativa por SSH:

bash

ssh usuario@192.168.0.2

2⃣ Protección de la MicroSD con Log2Ram (Especial para Trixie)

Dado que Pi-hole escribe de manera constante registros (logs) y consultas de red, las bases de datos destruyen las tarjetas SD tradicionales a largo plazo. Redirigiremos todos los logs a un disco virtual montado en la memoria RAM.

Debido a un bug estructural actual en Debian 13 (bug=1122989), la instalación de Log2Ram debe realizarse mediante repositorios APT oficiales fijando prioridades estricta de paquetes (pinning):

bash

# 1. Cargar datos del sistema y la clave del repositorio
. /etc/os-release
sudo wget -O /usr/share/keyrings/azlux-archive-keyring.gpg https://azlux.fr
# 2. Agregar las fuentes de software de Azlux
sudo tee /etc/apt/sources.list.d/azlux.list >/dev/null << EOF
deb [signed-by=/usr/share/keyrings/azlux-archive-keyring.gpg] http://azlux.fr \$VERSION_CODENAME main
EOF
# 3. Aplicar regla de Pinning indispensable para Trixie
sudo tee /etc/apt/preferences.d/log2ram.pref >/dev/null << EOF
Package: log2ram
Pin: origin packages.azlux.fr
Pin-Priority: 1001
EOF
# 4. Actualizar dependencias e instalar de manera nativa
sudo apt update
sudo apt install log2ram rsync -y
# 5. REINICIAR obligatoriamente
sudo reboot

Verificá que esté activo y corriendo en RAM ejecutando: systemctl status log2ram.

3⃣ Blindaje de Red Local (IP Estática en Trixie)

Dado que Trixie utiliza Netplan renderizado a través de NetworkManager, podemos fijar de forma nativa y robusta la dirección IP estática de la Pi mediante nmcli, asignando DNS de contingencia puros de Cloudflare (1.1.1.1 y 1.0.0.1):

bash

sudo nmcli connection modify "netplan-eth0" ipv4.addresses 192.168.0.2/24
sudo nmcli connection modify "netplan-eth0" ipv4.gateway 192.168.0.1
sudo nmcli connection modify "netplan-eth0" ipv4.dns "1.1.1.1,1.0.0.1"
sudo nmcli connection modify "netplan-eth0" ipv4.method manual
sudo nmcli connection up "netplan-eth0"

Por cuestiones de latencia y estabilidad del servidor de infraestructura de red, se recomienda mantener apagada la interfaz inalámbrica si está conectada por cable LAN:

bash

sudo nmcli radio wifi off

4⃣ Instalación de Pi-hole v6

Al utilizar una rama alpha/testing del sistema operativo, el asistente oficial detendrá la instalación por incompatibilidad. Lo descargamos y forzamos su ejecución omitiendo la verificación de la versión de OS:

bash

wget -O basic-install.sh https://pi-hole.net
sudo PIHOLE_SKIP_OS_CHECK=true bash basic-install.sh

Parámetros clave en el asistente azul:

1. Aceptá la IP estática local (192.168.0.2).
2. Elegí transitoriamente el proveedor upstream de Cloudflare.
3. Habilitá la interfaz web (Web Admin Interface) y su servidor lighttpd.
4. Activá el Query Logging y seleccioná el nivel de privacidad Level 0 (Show everything). Al contar con Log2Ram, las estadísticas se guardan de forma segura en la memoria volatil sin desgastar tu disco físico.
5. Anotá la contraseña de administrador asignada al finalizar.

5⃣ Implementación de Unbound (Resolvedor DNS Recursivo propio)

Para prescindir de intermediarios masivos (como Google o Cloudflare) y resguardar por completo la privacidad, instalaremos Unbound para que la Raspberry Pi le consulte de forma directa a los servidores raíz globales (Root Servers).

bash

# 1. Instalar el software
sudo apt install unbound -y
# 2. Desactivar el servicio conflictivo de Debian
sudo systemctl disable --now unbound-resolvconf.service

Configuramos el archivo de vinculación ejecutando sudo nano /etc/unbound/unbound.conf.d/pi-hole.conf y pegando lo siguiente:

yaml

server:
    interface: 127.0.0.1
    port: 5335
    do-ip4: yes
    do-udp: yes
    do-tcp: yes
    access-control: 127.0.0.0/8 allow
    harden-glue: yes
    harden-dnssec-stripped: yes
    use-caps-for-id: no
    edns-buffer-size: 1232
    prefetch: yes
    num-threads: 1
    private-address: 192.168.0.0/16
    private-address: 169.254.0.0/16
    private-address: 172.16.0.0/12
    private-address: 10.0.0.0/8
    private-address: fd00::/8
    private-address: fe80::/10

Reiniciá el servicio: sudo service unbound restart.

Enlace en la Interfaz Web de Pi-hole:

• Ingresá a http://192.168.0.2
• Andá a Settings > DNS. Desmarcala de todos los servidores externos y en el campo Custom 1 (IPv4) colocá: 127.0.0.1#5335.
• Desmarcá la opción «Use DNSSEC» dentro de Pi-hole, dado que Unbound realiza esta verificación criptográfica de manera nativa e independiente.

6⃣ Integración Remota Segura con Tailscale

Montaremos la red mallada VPN para acceder a nuestro Pi-hole desde el celular o cualquier laptop en la calle, cifrando el tráfico de red de forma directa.

1. Instalá mediante el script automatizado oficial:bashcurl -fsSL https://tailscale.com | sh Use code with caution.
2. Habilitá el enrutamiento IP profundo de paquetes dentro del Kernel de Linux (indispensable para reenviar peticiones como Exit Node):bashecho 'net.ipv4.ip_forward = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf echo 'net.ipv6.conf.all.forwarding = 1' | sudo tee -a /etc/sysctl.d/99-tailscale.conf sudo sysctl -p /etc/sysctl.d/99-tailscale.conf Use code with caution.
3. Iniciá el enlace de red anunciando el nodo:bashsudo tailscale up --advertise-exit-node Use code with caution.
4. Copiá el enlace entregado por la consola, logueate con tu cuenta personal única en el navegador y vinculá el dispositivo.

Modificaciones Mandatorias en el Panel Web de Tailscale:

• En Machines, buscá la Raspberry Pi, ingresá a Edit route settings y activá Use as exit node.
• En la pestaña DNS, ve a Nameservers > Add nameserver > Custom… e introducí estrictamente la IP de Tailscale de tu Raspberry Pi (la que comienza con 100.X.X.X). Activá el interruptor Override local DNS.
• En la Interfaz Web de Pi-hole: En Settings > DNS > Interface settings, tildá obligatoriamente la opción Permit all origins (o modo experto). De lo contrario, Pi-hole descartará las peticiones provenientes de la interfaz virtual remota (tailscale0).

7⃣ El Desafío de los Módems Restrictivos (Bypass para el hogar)

Muchos ISP (como los módems Sagemcom F@st de Telecentro) bloquean el cambio de DNS y la desactivación de IPv6 a nivel de firmware. Como el módem continúa enviando anuncios DNS por IPv6, los Smart TVs y celulares de la familia tienden a puentear la protección IPv4 del Pi-hole.

El Bypass Definitivo para toda tu Infraestructura

Dado que tus equipos dependen de la distribución Wi-Fi/LAN física del módem y no se puede desactivar IPv6 general en la red, debés forzar la configuración de tus equipos principales de la siguiente manera:

• En equipos Linux (Debian Sid): Evitá que NetworkManager capture las DNS del módem de internet inyectando la IP estática local del servidor y forzando su desacople:bashsudo nmcli connection modify "netplan-eth0" ipv4.dns "192.168.0.233" sudo nmcli connection modify "netplan-eth0" ipv6.dns "2606:4700:4700::1111" sudo nmcli connection modify "netplan-eth0" ipv4.ignore-auto-dns yes sudo nmcli connection modify "netplan-eth0" ipv6.ignore-auto-dns yes sudo nmcli connection up "netplan-eth0" Use code with caution.
• En Smart TVs y Celulares (Dentro de Casa): Si el firmware de la TV posee la opción, desactivá por completo el protocolo IPv6 en su menú de red. Modificá la configuración del Wi-Fi de DHCP a Estática / Manual, preservá sus IPs internas, pero asigná como DNS 1 la dirección de tu Raspberry Pi: 192.168.0.233.

8⃣ Optimización y Listas de Bloqueo Recomendadas (Adlists 2026)

Para maximizar el rendimiento de una Raspberry Pi 3 sin sobrecargar su memoria RAM, se desaconseja apilar decenas de listas obsoletas. La recomendación de la comunidad es implementar la lista curada HaGeZi Multi PRO:

1. Navegá en el panel de Pi-hole a Group Management > Adlists.
2. Agregá la URL cruda de HaGeZi PRO:texthttps://githubusercontent.com Use code with caution.
3. Actualizá la base de datos de bloqueos ejecutando en la consola de la Pi:bashsudo pihole -g Use code with caution.

Esta lista consolidada proporciona una protección robusta contra trackers, anuncios intrusivos y telemetría de Smart TVs, arrojando una tasa de falsos positivos virtualmente nula, ideal para la convivencia digital de toda la familia.

Espero que este PoC les sea de utilidad para blindar sus redes locales y asegurar sus conexiones remotas. ¡Cualquier duda los leo en los comentarios!

Hoy en día, la mayoria de las distribuciones que usamos son de 64 bits, claro que nos pudo quedar algún equipo que por compatibilidad haya quedado en arquitectura de 32 bits.

Para esta situación nos basamos en https://wiki.debian.org/CrossGrading

Como primer paso siempre tener el 100 % de los paquetes actualizados.

sudo apt update

Con o sin sudo si están como root

Estar en la última versión estable de Debian, consultar en https://www.debian.org/releases/

Al día de hoy es “bookworm” con soporte activo.

Estando el sistema gozando de buen estado de salud vamos a agregar la arquitectura AMD64

sudo dpkg --add-architecture amd64
sudo apt update

Luego vamos a instalar la imagen de 64 bits

sudo apt install linux-image-amd64:amd64

Y Reiniciamos el equipo

Luego limpiamos la cache de apt y reitentamos un upgrade

sudo apt clean
sudo apt upgrade

Ahora vamos a bajar los paquetes dpkg tar apt en ambas versiones

# bookworm:
sudo apt --download-only install dpkg:amd64 tar:amd64 apt:amd64 dpkg:i386- tar:i386- apt:i386-
sudo dpkg --install /var/cache/apt/archives/*_amd64.deb

Aca estamos forzando la instalación de los paquetes mencionados en 64 bits. Es necesario reintentar varias veces este paso, hasta que la arquitectura sea 64 bits y la foránea 32 bits.

# Should print "amd64":
sudo dpkg --print-architecture
# Should print "i386":
sudo dpkg --print-foreign-architectures

Volver a actualizar una vez tengamos los resultados deseados:

sudo apt update
sudo apt upgrade
sudo apt full-upgrade

Si es necesario bajar algún paquete base de manera particular realizarlo, como ejemplo:

 sudo apt --download-only install gzip:amd64 perl-base:amd64 gzip:i386 perl-base:i386
sudo apt --download-only install liblocale-gettext-perl:amd64 libtext-charwidth-perl:amd64 libtext-iconv-perl:amd64 perlapi-5.36.0:amd64 liblocale-gettext-perl:i386- libtext-charwidth-perl:i386- libtext-iconv-perl:i386- perlapi-5.36.0:i386-
sudo dpkg --install /var/cache/apt/archives/*_amd64.deb

Purgar paquetes obsoletos i386

# Get auto-installed packages:
sudo apt-mark showauto | sed -n -e's/:i386$//p' > auto-package-list

# Reinstall everything:
sudo apt install \
    $(dpkg -l | awk '$1 ~ /^.i/ && $2 ~ /:i386$/ { sub(":i386", ""); print $2 }')
# Or for bookworm:
sudo apt install --allow-remove-essential \
    $(dpkg -l | awk '$1 ~ /^.i/ && $2 ~ /:i386$/ { sub(":i386", ""); print $2; print $2 ":i386-" }')

Resetear marca de paquetes autoinstalados i386

# Reinstall everything:
sudo apt install \
    $(dpkg -l | awk '$1 ~ /^.i/ && $2 ~ /:i386$/ { sub(":i386", ""); print $2 }')
# Or for bookworm:
sudo apt install --allow-remove-essential \
    $(dpkg -l | awk '$1 ~ /^.i/ && $2 ~ /:i386$/ { sub(":i386", ""); print $2; print $2 ":i386-" }')

Concluir migración

dpkg --get-selections \
    | sed -ne 's/:i386\(\t*install$\)/:amd64\1/p' \
    | dpkg --set-selections
sudo apt -f install

Espero les sirva a muchos, al menos cómo un POC posible.

Presten mucha atención al ritmo juglaresco también.

“La primera mentira” de Silvio Rodríguez, centrado en el estribillo de la canción y el mensaje profundo que transmite:

Letra clave: el estribillo verdadero

El verdadero estribillo —aunque no se repite como en la estructura clásica— es el fragmento final de la canción, que funciona como clímax emocional y simbólico:

«Yo quiero una princesa convertida en un dragón,
yo quiero el hacha de un brujo para echarla en mi zurrón,
yo quiero un vellocino de oro para un reino,
yo quiero que Virgilio me lleve al infierno,
yo quiero ir hasta el cielo en un frijol sembrado,
y ya.»

¿Qué significa este estribillo?

Este pasaje encierra el sentido más profundo de la canción y puede analizarse desde varias dimensiones:

1. El deseo de lo imposible

Cada verso expresa un anhelo fantástico o mitológico:

• “Una princesa convertida en un dragón”: transforma el amor idealizado en una criatura feroz. Tal vez se refiere al desencanto o a la revelación de que lo que parecía perfecto era complejo y salvaje.
• “El hacha de un brujo para echarla en mi zurrón”: alude a querer apropiarse de un poder mágico, tener control sobre lo oculto o lo incomprensible.
• “Un vellocino de oro para un reino”: referencia al mito de Jasón; representa la búsqueda heroica de un ideal glorioso, a menudo inalcanzable.
• “Que Virgilio me lleve al infierno”: alusión directa a La Divina Comedia de Dante. Virgilio guía a través del infierno, símbolo de la búsqueda de sentido en medio del sufrimiento.
• “Ir hasta el cielo en un frijol sembrado”: referencia al cuento infantil de Jack y las habichuelas mágicas, donde algo humilde da acceso a lo divino o sobrenatural.
• “Y ya”: remate seco, despojado, que cierra el deseo con resignación o certeza infantil. Es como decir: “Eso es todo lo que quiero. Nada más. Punto.”

2. La confesión del mentiroso

Este estribillo no lo canta el narrador, sino el “primer hombre que mintió”. Es decir: la mentira fundacional no nació de maldad, sino de deseo.
Ese hombre —descubierto por el narrador como el responsable de su desencanto— no es un villano, sino otro soñador.

Al revelarse, el mentiroso no se defiende: simplemente enumera sus sueños imposibles, como diciendo que mintió porque también quería creer. Es una imagen profundamente humana.

¿Qué mensaje nos deja la canción?

1. La mentira como origen de la fantasía

La canción plantea que la “primera mentira” no es solo un acto de traición, sino el punto de partida del deseo, de la imaginación, del mito.
Mentimos porque necesitamos creer en cosas que nos dan sentido, aunque no sean reales.

2. La pérdida de la inocencia

El protagonista va descubriendo que el mundo no es como lo soñó (la piedra no canta, el agua no es de oro…). Al final, encuentra que esa primera mentira estaba motivada por los mismos sueños que él tenía.

3. Una visión compasiva del autoengaño

Silvio no condena al mentiroso. Al contrario: lo presenta como alguien que quiso soñar también, que necesitaba crear cuentos para vivir.
La canción nos lleva a empatizar con quien miente, no por manipular, sino por no querer renunciar a lo mágico.

Conclusión

“La primera mentira” es una meditación poética sobre el origen del autoengaño y el poder del deseo.
Nos muestra que las grandes mentiras no siempre vienen del cinismo, sino del anhelo profundo por creer en lo extraordinario.

El estribillo —ese listado de sueños imposibles y hermosos— nos recuerda que todos, en algún momento, hemos querido creer en lo imposible, aunque sepamos que no es verdad. Y a veces, eso también nos salva.

sudo apt-get install fdpowermon

Una vez instalado lo agregaremos al autostart
sudo gedit /etc/xdg/lxsession/LXDE/autostart
y agregamos la siguiente línea
@fdpowermon

En caso de contar con un archivo de inicio local, a nivel usuario
gedit ~/.config/lxsession/LXDE/autostart
y agregamos ahí la línea mencionada anteriormente.

Hasta la próxima

Primero lo descargamos desde: https://zoom.us/download#client_4meeting

o podemos hacerlo desde la terminal:

wget https://zoom.us/client/latest/zoom_amd64.deb

Luego tenemos que instalar las dependencias, en este caso:

sudo aptitude install libxcb-xtest0

y luego terminamos la instalación:

sudo dpkg -i zoom_amd64.deb

y lo ejecutamos:

zoom

Esto es todo y lo podemos usar en estas distros Debian-Based

Entrada actualizada para agregar compatibilidad con SCVMM 2016

Credits are from https://vniklas.djungeln.se/2013/09/29/ Niklas AkerlundGet an inventory of all VM’s from System Center Virtual Machine Manager including the vCPU’s, memory, all VHD´s, IP addresses.  Report to CSV and HTML. Adapted to work with last actuallly SCVMM version 3.2.8224

__________________________

Créditos son de Niklas AkerlundGet https://vniklas.djungeln.se/2013/09/29/

Exportar un inventario de todas las VM’s es SCVMM. Se exporta a CSV y HTML, compatible con la 3.2.8224 /SCVMM 2016 y más.

Get an inventory of all VM’s from System Center Virtual Machine Manager including the vCPU’s, memory, up to 3 VHD´s, up to 4 interfaces and IP addresses.  Report to CSV and HTML. Adapted to work with SCVMM version 3.2.8224. and at least SCVMM 2016 UR7

Thanks to @leleco for the suggestions and collaboration improvements

Example:

Get-SCVMInventory -report

Give a reports for «All Hosts»

Get-SCVMInventory -VMHost SERVER01

Give data from SERVER01 Hyper-v Host.

Publicado también en https://gallery.technet.microsoft.com/scriptcenter/Get-SCVMMInventory-Get-053afdc1

function Get-SCVMInventory
{
    [CmdletBinding()]

    Param
    (

        $VMHostGroup = "All Hosts",
        [Parameter(ValueFromPipeline=$True)][Alias('ClusterName')]
        $VMHostCluster = $null,
        $VMHost = $null,
        [switch]$report,
        [string]$path =".\",
        [string]$CSVFile = "VMdata.csv",
        [string]$HTMLReport = "VMdata.html"
    )

    Begin
    {
        if(!(Get-Module virtualmachinemanager)){
            Import-Module Hyper-V
            Import-Module virtualmachinemanager
        }
        if(Get-SCVMMServer localhost | where ProductVersion -gt 3){
            $isR2 = $true
        }else{
            $isR2 = $false
        }
    }
    Process
    {
         if ($VMHostCluster -eq $null){
            if($VMHost -eq $null){
                $VMHosts = (Get-SCVMHostGroup -Name $VMhostGroup).AllChildHosts
            }else{
                $VMHosts = Get-SCVMHost $VMHost
            }
         }else{
            $VMHosts = (Get-SCVMHostCluster -Name $VMHostCluster).Nodes
         }
            $VMs = $VMHosts | Get-SCVirtualMachine
            $reportArray = @()
            foreach ($VM in $VMs){
                Write-Verbose $VM.Name
                    $vNics = $VM.VirtualNetworkAdapters
                    $VHDConf = $VM.VirtualHardDisks
                    $driveConf = $VM.VirtualDiskDrives
                    if(($vNics[0].IPv4Addresses -ne $null)){
                        Write-Verbose $vNics[0].IPv4Addresses[0]
                        $IPAddress1 = $vNics[0].IPv4Addresses[0]

                    }else{
                        if (!$isR2){
                            if(($vNics[0].IPv4Addresses -ne $null)){
                            $IPAddress1= (Hyper-V\Get-VMNetworkAdapter -ComputerName $VM.HostName -VMName $VM.Name).IPv4Addresses[0]
                            }else{
                                $IPAddress1 = "N/A"
                            }
                        }else{
                            Write-Verbose "NO IP"
                            $IPAddress1 = "N/A"
                        }
                    }
                    if(($vNics[1].IPv4Addresses -ne $null)){
                        Write-Verbose $vNics[1].IPv4Addresses[0]
                        $IPAddress2 = $vNics[1].IPv4Addresses[0]

                    }else{
                        if (!$isR2){
                            if(($vNics[1].IPv4Addresses -ne $null)){
                            $IPAddress2= (Hyper-V\Get-VMNetworkAdapter -ComputerName $VM.HostName -VMName $VM.Name).IPv4Addresses[0]
                            }else{
                                $IPAddress2 = "N/A"
                            }
                        }else{
                            Write-Verbose "NO IP"
                            $IPAddress2 = "N/A"
                        }
                    }
                    if(($vNics[2].IPv4Addresses -ne $null)){
                        Write-Verbose $vNics[2].IPv4Addresses[0]
                        $IPAddress3 = $vNics[2].IPv4Addresses[0]

                    }else{
                        if (!$isR2){
                            if(($vNics[2].IPv4Addresses -ne $null)){
                            $IPAddress3= (Hyper-V\Get-VMNetworkAdapter -ComputerName $VM.HostName -VMName $VM.Name).IPv4Addresses[0]
                            }else{
                                $IPAddress3 = "N/A"
                            }
                        }else{
                            Write-Verbose "NO IP"
                            $IPAddress3 = "N/A"
                        }
                    }
                    if(($vNics[3].IPv4Addresses -ne $null)){
                        Write-Verbose $vNics[3].IPv4Addresses[0]
                        $IPAddress4 = $vNics[3].IPv4Addresses[0]

                    }else{
                        if (!$isR2){
                            if(($vNics[3].IPv4Addresses -ne $null)){
                            $IPAddress4= (Hyper-V\Get-VMNetworkAdapter -ComputerName $VM.HostName -VMName $VM.Name).IPv4Addresses[0]
                            }else{
                                $IPAddress4 = "N/A"
                            }
                        }else{
                            Write-Verbose "NO IP"
                            $IPAddress4 = "N/A"
                        }
                    }
                    if($VM.VMCheckpoints){
                    $Snapshots = "Yes"
                    }else{
                    $Snapshots = "No"
                    }

                    $data = [ordered]@{
                    VMName = $VM.Name
                    vCPUs = $VM.CPUCount
                    
                    MemoryAssignedMB = $VM.MemoryAssignedMB
                    Status = $VM.Status
                    OperatingSystem = $VM.OperatingSystem
                    HostName = $VM.HostName
                     TotalSizeGB = $VM.TotalSize/1GB -as [int]
                    vNics = $vNics.Count                                                         
                    VirtualNetwork1 = $vNics[0].VirtualNetwork
                    MacAddressType1 = $vNics[0].MacAddressType
                    MacAddress1 = $vNics[0].MacAddress
                    VirtualNetworkAdapterType1 = $vNics[0].VirtualNetworkAdapterType
                    VLANEnabled1 = $vNics[0].VlanEnabled
                    VLanID1 = $vNics[0].VlanID 
                    IPAddress1 = $IPAddress1

                    VirtualNetwork2 = $vNics[1].VirtualNetwork
                    MacAddressType2 = $vNics[1].MacAddressType
                    MacAddress2 = $vNics[1].MacAddress
                    VirtualNetworkAdapterType2 = $vNics[1].VirtualNetworkAdapterType
                    VLANEnabled2 = $vNics[1].VlanEnabled
                    VLanID2 = $vNics[1].VlanID 
                    IPAddress2 = $IPAddress2

                    VirtualNetwork3 = $vNics[2].VirtualNetwork
                    MacAddressType3 = $vNics[2].MacAddressType
                    MacAddress3 = $vNics[2].MacAddress
                    VirtualNetworkAdapterType3 = $vNics[2].VirtualNetworkAdapterType
                    VLANEnabled3 = $vNics[2].VlanEnabled
                    VLanID3 = $vNics[2].VlanID 
                    IPAddress3 = $IPAddress3

                    VirtualNetwork4 = $vNics[3].VirtualNetwork
                    MacAddressType4 = $vNics[3].MacAddressType
                    MacAddress4 = $vNics[3].MacAddress
                    VirtualNetworkAdapterType4 = $vNics[3].VirtualNetworkAdapterType
                    VLANEnabled4 = $vNics[3].VlanEnabled
                    VLanID4 = $vNics[3].VlanID 
                    IPAddress4 = $IPAddress4

                    NumberofVHD = $VHDConf.Count
                    VHDName = $VHDConf[0].Name
                    VHDFormatType = $VHDconf[0].VHDFormatType
                    VHDType = $VHDconf[0].VHDType
                    VHDSize = $VHDconf[0].MaximumSize/1GB -as [int]
                    VHDCurrentSize = $VHDconf[0].Size/1GB -as [int]
                    VHDBusType = $driveConf[0].BusType
                    VHDBus = $driveConf[0].Bus
                    VHDLUN = $DriveConf[0].Lun
                    VHDDatastore = $VHDconf[0].Directory

                    VHDName2 = $VHDConf[1].Name
                    VHDFormatType2 = $VHDconf[1].VHDFormatType
                    VHDType2 = $VHDconf[1].VHDType
                    VHDSize2 = $VHDconf[1].MaximumSize/1GB -as [int]
                    VHDCurrentSize2 = $VHDconf[1].Size/1GB -as [int]
                    VHDBusType2 = $driveConf[1].BusType
                    VHDBus2 = $driveConf[1].Bus
                    VHDLUN2 = $DriveConf[1].Lun
                    VHDDatastore2 = $VHDconf[1].Directory

                    VHDName3 = $VHDConf[2].Name
                    VHDFormatType3 = $VHDconf[2].VHDFormatType
                    VHDType3 = $VHDconf[2].VHDType
                    VHDSize3 = $VHDconf[2].MaximumSize/1GB -as [int]
                    VHDCurrentSize3 = $VHDconf[2].Size/1GB -as [int]
                    VHDBusType3 = $driveConf[2].BusType
                    VHDBus3 = $driveConf[2].Bus
                    VHDLUN3 = $DriveConf[2].Lun
                    VHDDatastore3 = $VHDconf[2].Directory

                    StartMemoryGB = $VM.Memory/1024
                    DynamicMemory = $VM.DynamicMemoryEnabled
                    DynamicMemoryDemandMB = $VM.DynamicMemoryDemandMB
                    DynamicMemoryStatus = $VM.DynamicMemoryStatus -as [int]
                    DynamicMemoryMinMB = $VM.DynamicMemoryMinimumMB -as [int]
                    DynamicMemoryMaxGB = $VM.DynamicMemoryMaximumMB/1024 -as [int]
                    HasSnaphots = $Snapshots
                    Owner = $VM.Owner
                    Cloud = $VM.Cloud
                    CreationTime = $VM.CreationTime
                    HasVMAdditions = $VM.HasVMAdditions
                    VMAddition = $VM.VMAddition
                   
            }
            $obj= New-Object -TypeName PSObject -property $data
            $reportArray +=$obj 
            Write-Output $obj
            }

            if($report){
                # $reportArray
                $CSVReport = $path + $CSVFile
                $HTMLReport = $path + $HTMLReport
                $reportArray | Export-Csv -Path $CSVReport -NoTypeInformation -UseCulture
                $reportArray | ConvertTo-HTML | Out-File $HTMLReport
            }
    }
    End
    {
        # Should we clean anything?
    }
}

svn co https://svn.code.sf.net/p/qmc2/code/trunk qmc2-svn

cd qmc2-svn/

make os-detect

sudo apt-get install libSDL1.2-dev libsdl2-dev

sudo dpkg-reconfigure dash

Choose No

sudo apt-get install libqtwebkit-dev

sudo apt-get install libphonon-dev

make

sudo make install

For Arcade

sudo apt-get install libqt4-opengl-dev libqt4-declarative-shaders libqt4-declarative-particles qtmobility-dev

make arcade DISTCFG=1
sudo make arcade-install DISTCFG=1

For CHDMAN

make qchdman DISTCFG=1

sudo make qchdman-install DISTCFG=1

Optionally convert & install the man-pages:

make man
sudo make man-install

http://wiki.batcom-it.net/index.php?title=The_%27ultimate%27_guide_to_QMC2#Building_and_installing_QMC2_from_source

Add-WindowsFeature AD-Domain-Services

Then install Role:

Install-ADDSDomainController -CreateDnsDelegation:$false -DatabasePath 'D:\Windows\NTDS' -DomainName 'MyExistentDomain.local' -InstallDns:$true -LogPath 'D:\Windows\NTDS' -NoGlobalCatalog:$false -SiteName 'MySite' -SysvolPath 'D:\Windows\SYSVOL' -NoRebootOnCompletion:$true -Force:$true -Credential (Get-Credential MyExistentDomain\AdminUser)

Thanks to Mike Robbins http://mikefrobbins.com/2013/03/14/use-powershell-to-add-an-additional-domain-controller-to-an-existing-windows-server-2012-active-directory-domain/

New-ItemProperty -Path 'HKLM:\System\CurrentControlSet\Control\Terminal Server' -Name 'fDenyTSConnections' -Value 0 -PropertyType dword -Force

To Enable RDP

New-ItemProperty -Path 'HKLM:\System\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp' -Name 'UserAuthentication' -Value 1 -PropertyType dword -Force

To Enable NLA

Enable-NetFirewallRule -DisplayGroup 'Remote Desktop'

To Enable on Firewall

Unos hermanos judíos huyen a través de Francia durante la ocupación alemana, en plena Segunda Guerra Mundial.