# PowerShell práctico: del primer comando a tu primera automatización
**ÆSIR Knowledge · Systems 001 · Edición corregida para lectura · octubre de 2026**
**Nivel:** inicial a intermedio · **Plataforma:** Windows 10/11 y PowerShell 5.1/7

## Prefacio — tomar el control sin romperlo
Windows no es solamente una colección de ventanas. Tiene servicios, procesos, carpetas, redes y tareas que pueden administrarse con instrucciones reproducibles. PowerShell es una consola y un lenguaje de automatización capaz de consultar y modificar ese entorno. Aprenderlo no significa ejecutar scripts encontrados al azar: significa comprender qué hace cada comando y verificar su resultado.

Este libro propone una disciplina: observar primero, simular después y modificar únicamente cuando el efecto esté claro. No necesitás permisos de administrador para empezar a aprender.

## 1. Entender la consola
Abrí Inicio, escribí «PowerShell» y elegí la aplicación de usuario estándar. La línea que aparece, como `PS C:\Users\...`, indica el directorio actual. Los comandos nativos de PowerShell suelen tener formato **Verbo-Sustantivo**.

Probá:
```powershell
Get-Date
Get-Location
Get-Help Get-Process -Examples
Get-Command *Service* | Select-Object -First 10
```
`Get-Date` muestra la fecha local; `Get-Location` informa la carpeta actual; `Get-Help` presenta ayuda. El último comando lista diez acciones relacionadas con servicios. Ninguno requiere alterar el sistema.

**Experimento:** ejecutá `Get-Process | Sort-Object CPU -Descending | Select-Object -First 8 Name,Id,CPU`. ¿Qué proceso acumuló más tiempo de CPU? Ese valor no es uso instantáneo: es tiempo acumulado, por lo tanto no equivale al porcentaje actual.

## 2. El pipeline y los objetos
CMD trata muchas salidas como texto. PowerShell transmite objetos entre comandos mediante `|`. Por eso es posible filtrar por propiedades en lugar de extraer columnas a mano.

```powershell
Get-Process | Where-Object {$_.WorkingSet64 -gt 500MB} |
  Select-Object Name,Id,@{Name='RAM_MB';Expression={[math]::Round($_.WorkingSet64/1MB,1)}} |
  Sort-Object RAM_MB -Descending
```
Cada comando hace una tarea pequeña: obtiene procesos, filtra, selecciona campos y ordena. El pipeline permite leer la intención del script, no solo su sintaxis.

Una variable empieza con `$`: `$nombre = 'ÆSIR'`. Para explorar un objeto usá `Get-Member`, por ejemplo `Get-Process | Get-Member | Select-Object -First 12`.

## 3. Archivos: localizar sin borrar
El manejo de archivos es el primer terreno donde la prudencia tiene un beneficio tangible. Inventariá antes de mover; verificá antes de eliminar.

```powershell
$carpeta = Join-Path $HOME 'Documents'
Get-ChildItem $carpeta -File -Recurse -ErrorAction SilentlyContinue |
  Sort-Object Length -Descending |
  Select-Object -First 15 FullName,@{Name='MB';Expression={[math]::Round($_.Length/1MB,1)}}
```
Esto identifica archivos grandes, pero no declara que sean basura. Una copia de seguridad puede ocupar mucho espacio porque justamente está protegiendo información valiosa.

**Importante:** el próximo ejemplo SÍ modifica el sistema de archivos: crea una carpeta temporal y escribe un archivo de texto. No es de solo lectura. Ejecutalo únicamente en tu propio equipo y verificá la ruta mostrada antes de continuar.

Para practicar una modificación segura creá una carpeta de laboratorio:
```powershell
$lab = Join-Path $env:TEMP 'aesir-ps-lab'
New-Item -ItemType Directory -Path $lab -Force | Out-Null
'Mi primera nota' | Set-Content (Join-Path $lab 'nota.txt') -Encoding UTF8
Get-Content (Join-Path $lab 'nota.txt')
```
No trabajes directamente en directorios críticos ni utilices `Remove-Item -Recurse` sobre rutas que no verificaste.

## 4. Servicios, inicio y tareas
Un servicio puede ejecutarse sin ventana visible. Consultá su estado antes de decidir si conviene detenerlo.

```powershell
Get-Service | Where-Object Status -eq 'Running' |
  Select-Object -First 15 Name,DisplayName,Status
Get-CimInstance Win32_StartupCommand | Select-Object Name,Command,Location
```
Un elemento desconocido no es necesariamente malware. Algunos procesos son componentes firmados de Windows, controladores o herramientas corporativas. Investigar el fabricante, la ruta y la firma digital ayuda a priorizar una revisión.

**Ejercicio:** elegí un programa que reconocés al inicio. Documentá por qué arranca, dónde está y si realmente lo necesitás; no lo desactives automáticamente.

## 5. Red local y conexiones
Conectividad no equivale a seguridad. El equipo puede tener servicios abiertos solo para la misma PC, para la red interna o hacia Internet.

```powershell
Get-NetTCPConnection -State Listen |
  Select-Object LocalAddress,LocalPort,OwningProcess |
  Sort-Object LocalPort
Get-NetIPConfiguration
```
Interpretación: `127.0.0.1` suele indicar acceso local; `0.0.0.0` puede indicar escucha en todas las interfaces IPv4. Eso amerita revisar el firewall y el programa propietario, no cerrar puertos a ciegas.

**Desafío:** elegí una conexión, obtené el PID y buscá el proceso mediante `Get-Process -Id 1234`, reemplazando **1234** por el identificador numérico que realmente obtuviste. Los signos `<` y `>` de los manuales representan marcadores de posición y no deben copiarse. Registrá nombre y ruta ejecutable, evitando pegar información privada en un sitio público.

## 6. Tu primer script con registro
Un script `.ps1` permite reunir pasos verificables. Empezá con uno de solo lectura y guardá su salida.

```powershell
$salida = Join-Path $HOME 'Documents\reporte-sistema.txt'
$fecha = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
$procesos = Get-Process | Sort-Object CPU -Descending | Select-Object -First 10
@(
  "Reporte ÆSIR - $fecha"
  "Equipo: $env:COMPUTERNAME"
  "Procesos con mayor CPU acumulado:"
  ($procesos | Format-Table Name,Id,CPU -AutoSize | Out-String)
) | Set-Content -Path $salida -Encoding UTF8
Write-Output "Informe generado: $salida"
```
El script no prueba la integridad del equipo; genera un punto de observación. Para automatizarlo, guardalo en una carpeta controlada, probalo manualmente y recién después evaluá usar el Programador de tareas.

## 7. Errores, simulación y confirmaciones
Los scripts confiables contemplan fallos. `Test-Path` confirma una ruta; `-ErrorAction Stop` hace que ciertos errores puedan capturarse mediante `try/catch`; `-WhatIf` simula operaciones cuando el comando lo soporta.

```powershell
$origen = Join-Path $env:TEMP 'aesir-ps-lab\nota.txt'
if (Test-Path $origen) {
  Copy-Item $origen (Join-Path $env:TEMP 'aesir-ps-lab\copia.txt') -WhatIf
} else {
  Write-Warning 'No se encontró el archivo de práctica.'
}
```
La simulación es especialmente importante al trabajar con servicios, permisos, registro y discos. No desactives Defender, actualizaciones ni políticas de ejecución simplemente para que un script descargado funcione.

## 8. Un método de seguridad doméstica
La defensa tiene varias capas: cuentas con autenticación fuerte, Windows actualizado, aplicaciones de origen verificable, copias desconectadas o versionadas, permisos mínimos y monitoreo de eventos relevantes.

PowerShell ayuda a inventariar:
```powershell
Get-ComputerInfo | Select-Object WindowsProductName,WindowsVersion,OsBuildNumber
Get-MpComputerStatus | Select-Object AntivirusEnabled,RealTimeProtectionEnabled
```
La disponibilidad de esos comandos depende de versión, permisos y proveedor antivirus. No reportes «todo seguro» a partir de dos campos. Una auditoría requiere alcance, evidencia y una lista explícita de lo no comprobado.

## 9. Proyecto final: auditoría de solo lectura
Construí un reporte que capture versión del sistema, procesos, servicios, conexiones locales y fecha. Guardalo en un archivo privado. Repetilo una semana después y compará: ¿aparecieron programas nuevos?, ¿cambiaron puertos?, ¿hubo actualizaciones?

Separá cada hallazgo en **verificado**, **requiere investigación** y **sin datos suficientes**. Ese hábito vale más que cualquier lista de «comandos secretos».

## Evaluación final
1. ¿Qué diferencia existe entre una salida de texto y un pipeline de objetos?
2. ¿Por qué una carpeta grande no implica que deba borrarse?
3. ¿Qué indica el puerto en escucha y qué *no* permite concluir?
4. ¿Cómo simularías una copia antes de ejecutarla?
5. ¿Qué controles aplicarías antes de programar un script recurrente?

**Respuesta orientativa:** un buen procedimiento identifica el objetivo, verifica datos, limita permisos, prueba sin consecuencias y deja evidencia del resultado.

**ÆSIR Knowledge · Nota editorial:** este material es educativo; ejecutá comandos únicamente sobre equipos que administrás. Edición corregida autorizada para lectura por el propietario. Comercialización y recursos audiovisuales sujetos a validación independiente.

## Anexo editorial A — Evaluación resuelta y evidencia
**Pregunta 1.** CMD normalmente transmite texto plano entre programas, mientras que PowerShell transmite objetos con propiedades y tipos. Para comprobarlo, ejecutá `Get-Process | Get-Member` y observá las propiedades; luego usá `Get-Process | Select-Object -First 1 Name,Id`. La diferencia no es que PowerShell nunca procese texto, sino que su pipeline nativo conserva objetos.
**Pregunta 2.** Un archivo grande puede ser una copia de seguridad, un archivo de trabajo o un recurso compartido. El tamaño no acredita inutilidad. Antes de eliminar, hay que identificar propietario, dependencia, respaldo y procedimiento de recuperación.
**Pregunta 3.** Un socket en escucha indica que un proceso acepta conexiones en determinada dirección y puerto. No prueba por sí solo exposición pública ni intención maliciosa; se necesitan reglas de firewall, rutas y contexto del proceso.
**Pregunta 4.** `Copy-Item -WhatIf` informa la operación prevista sin realizarla. Se confirma el archivo de origen con `Test-Path` y la ruta destino antes de ejecutar sin `-WhatIf`. El soporte de `-WhatIf` se comprueba con la ayuda del comando.
**Pregunta 5.** Antes de programar: ejecutar manualmente, limitar permisos, verificar rutas, documentar errores, prever reversión, evitar credenciales en texto plano y registrar resultado.
### Prueba de comprensión
En una PC ficticia, un programa ocupa 900 MB de RAM y escucha en 127.0.0.1:8080. Escribí tres conclusiones permitidas y tres que NO podés deducir. **Rúbrica:** se reconoce el consumo observado y escucha local; no se concluye malware, exposición externa ni necesidad de eliminarlo sin más evidencia.
**Estado del anexo:** contenido editorial añadido; el texto está autorizado para lectura; falta validar ejecución exhaustiva en distintas versiones de Windows. No constituye certificación.
