# Instalar la CLI

Instala la CLI `mikroscope` en Linux, macOS o Windows, elige el archivo de tu ordenador y no el del router, y verifícalo.

Source: https://docs.jmrp.io/mikroscope/es/install/cli/

Se publican dos programas a la vez y se ejecutan en máquinas distintas:

- **`mikroscope`**, la CLI y el colector, se ejecuta en **tu ordenador** —el
  portátil o el servidor donde escribes las órdenes—. Esta página va de ese.
- **`mikroscope-agent`** se ejecuta **en el router**, dentro de un contenedor.
  `mikroscope install` lo pone allí por ti; tú nunca lo ejecutas, y la única
  vez que lo descargas a mano es en la ruta `--agent-tar`.

Así que el archivo que quieres aquí lo decide **tu** sistema operativo y tu
CPU, no los del router. La arquitectura del router decide otra cosa, y esa
tabla está en [Requisitos](https://docs.jmrp.io/mikroscope/es/install/prerequisites/).

## Script de instalación

```sh
curl -fsSL https://raw.githubusercontent.com/jmrplens/mikroscope/main/install.sh | bash
```

o, en PowerShell en Windows:

```powershell
irm https://raw.githubusercontent.com/jmrplens/mikroscope/main/install.ps1 | iex
```

Cualquiera de los dos, [`install.sh`](https://github.com/jmrplens/mikroscope/blob/main/install.sh) o [`install.ps1`](https://github.com/jmrplens/mikroscope/blob/main/install.ps1), hace por su cuenta
todo lo que el resto de esta página hace a mano: averigua tu plataforma, resuelve la versión más
reciente, descarga ese archivo y el `checksums.txt` de la release, y **se niega a instalar nada
cuyo SHA-256 no sea el que publicó la release**. No hay opción para saltarse esa
comprobación. Un script metido por una tubería a una shell es la forma menos
inspeccionable de instalar algo, así que lo único que no debe hacer es fiarse de
lo que acaba de descargar. Donde `cosign` ya esté en la máquina, verifica además
que el `checksums.txt` salió del workflow de release; donde no esté, la suma de
comprobación se sigue exigiendo.

Instala en `/usr/local/bin` cuando se puede escribir ahí y en `~/.local/bin` si
no, y si el directorio no está en tu `PATH` imprime la línea que hay que añadir
y el fichero donde añadirla. No echará mano de `sudo` por su cuenta: un script
leído de la red no debería ser quien decide convertirse en root.

> **Ofrece la otra mitad, y no la hace en silencio**
>
> En una terminal pregunta después si poner el agente en un router. Decir que sí
> ejecuta `mikroscope doctor` —de solo lectura— y luego `mikroscope install`, que
> imprime cada orden de RouterOS que va a ejecutar y espera tu respuesta. No se
> le pasa nada que salte esa pregunta. Metido por una tubería sin terminal,
> imprime las dos órdenes en vez de preguntar, porque no hay nadie para
> contestar.

Dos argumentos, que son también las variables `VERSION` y `BIN_DIR` para poder
fijarlos a través de una tubería:

```sh
curl -fsSL .../install.sh | VERSION=1.6.1 BIN_DIR=~/bin bash
./install.sh --version 1.6.1 --dir ~/bin      # lo mismo, con el fichero descargado antes
```

El resto de esta página es lo que hacen esos scripts, plataforma por plataforma,
para quien prefiera leer él mismo la suma de comprobación del archivo — o esté
en una máquina donde `curl | bash` no es algo que se teclee.

## Elegir un archivo

| Tu máquina                            | Descarga                                       |
| ------------------------------------- | ---------------------------------------------- |
| Linux, PC o servidor normal           | `mikroscope_<versión>_linux_x86_64.tar.gz`     |
| Linux sobre ARM (Raspberry Pi 4/5, …) | `mikroscope_<versión>_linux_arm64.tar.gz`      |
| macOS, Apple silicon (M1 y posteriores) | `mikroscope_<versión>_darwin_arm64.tar.gz`   |
| macOS, Intel                          | `mikroscope_<versión>_darwin_x86_64.tar.gz`    |
| Windows                               | `mikroscope_<versión>_windows_x86_64.zip`      |

Están en la [última publicación](https://github.com/jmrplens/mikroscope/releases/latest).
Todo lo que empiece por `mikroscope-agent` es el otro programa.

## Instalación manual

- **Linux**

  1. Descarga el archivo y las sumas de verificación:

     ```sh
     VERSION=1.6.1
     curl -fsSLO https://github.com/jmrplens/mikroscope/releases/download/v$VERSION/mikroscope_${VERSION}_linux_x86_64.tar.gz
     curl -fsSLO https://github.com/jmrplens/mikroscope/releases/download/v$VERSION/checksums.txt
     ```

  2. Compruébalo contra la lista antes de descomprimirlo:

     ```sh
     sha256sum --ignore-missing -c checksums.txt
     ```

  3. Descomprime y ponlo donde el intérprete mira:

     ```sh
     tar xzf mikroscope_${VERSION}_linux_x86_64.tar.gz mikroscope
     sudo install -m 0755 mikroscope /usr/local/bin/mikroscope
     ```

     Sin `sudo`, `mkdir -p ~/.local/bin && install -m 0755 mikroscope ~/.local/bin/`
     también vale, siempre que `~/.local/bin` esté en tu `PATH`.

- **macOS**

  1. Descarga el archivo de tu CPU —`darwin_arm64` para Apple silicon,
     `darwin_x86_64` para Intel— y las sumas de verificación:

     ```sh
     VERSION=1.6.1
     curl -fsSLO https://github.com/jmrplens/mikroscope/releases/download/v$VERSION/mikroscope_${VERSION}_darwin_arm64.tar.gz
     curl -fsSLO https://github.com/jmrplens/mikroscope/releases/download/v$VERSION/checksums.txt
     ```

  2. Compruébalo:

     ```sh
     shasum -a 256 --ignore-missing -c checksums.txt
     ```

  3. Descomprime, quita la marca de cuarentena que le puso la descarga e
     instálalo:

     ```sh
     tar xzf mikroscope_${VERSION}_darwin_arm64.tar.gz mikroscope
     xattr -d com.apple.quarantine mikroscope 2>/dev/null || true
     sudo install -m 0755 mikroscope /usr/local/bin/mikroscope
     ```

     El binario no está firmado ni notarizado, así que sin esa línea de `xattr`
     macOS se niega a ejecutarlo y dice que «no se puede abrir porque no se puede
     verificar al desarrollador».

- **Windows**

  1. Descarga `mikroscope_<versión>_windows_x86_64.zip` y `checksums.txt` de la
     página de la publicación.

  2. Compruébalo en PowerShell, contra la línea de tu archivo en `checksums.txt`:

     ```powershell
     Get-FileHash .\mikroscope_1.6.1_windows_x86_64.zip -Algorithm SHA256
     ```

  3. Descomprímelo en un sitio permanente y pon esa carpeta en tu `PATH`:

     ```powershell
     Expand-Archive .\mikroscope_1.6.1_windows_x86_64.zip -DestinationPath $HOME\mikroscope
     $env:PATH += ";$HOME\mikroscope"
     ```

     Esa línea dura lo que la sesión. Para conservarla, añade la carpeta en
     **Configuración → Sistema → Acerca de → Configuración avanzada del sistema →
     Variables de entorno**, o:

     ```powershell
     [Environment]::SetEnvironmentVariable("PATH", "$env:PATH;$HOME\mikroscope", "User")
     ```

  > **ssh en Windows**
  >
  > La CLI llega al router por ssh, con el `ssh` y el `scp` que haya en tu `PATH`. Windows 10 y 11
  > traen OpenSSH: `Get-Command ssh` debería encontrarlo, y **Configuración → Sistema →
  > Características opcionales** lo instala si no. Un [script de RouterOS](https://docs.jmrp.io/mikroscope/es/install/script/)
  > no necesita ssh.

- **Con Go**

  Si tienes Go 1.27 o posterior y prefieres compilarla:

  ```sh
  go install github.com/jmrplens/mikroscope/cmd/mikroscope@latest
  ```

  Eso deja `mikroscope` en `$(go env GOPATH)/bin`, que es `~/go/bin` salvo que lo
  hayas movido, y ese directorio tiene que estar en tu `PATH`. Un binario
  compilado así informa de la versión del módulo y no del sello de una
  publicación.

  Un checkout compila cualquiera de los dos programas, que es la ruta de quien
  contribuye:

  ```sh
  git clone https://github.com/jmrplens/mikroscope
  cd mikroscope
  make build          # deja bin/mikroscope
  make build-agent    # deja bin/mikroscope-agent-<goarch>
  ```

## Verificar la instalación

```sh
mikroscope version
```

Imprime la versión, el commit y la fecha de compilación:

```text
mikroscope 1.6.1 (commit <commit>, built <time>)
```

Después, con un router al que apuntar:

```sh
mikroscope doctor --router admin@192.168.88.1
```

`doctor` no escribe nada. Lee el equipo, imprime qué es y marca cada requisito
como `ok` o `MISSING`, y como `WARN` la comprobación de aviso que encuentra algo,
con la orden que lo arregla —incluido el que nadie puede hacer en remoto—, y
después informa de lo que muestra un agente ya en marcha
([Comprobaciones de salud](https://docs.jmrp.io/mikroscope/es/install/prerequisites/#lo-que-muestra-el-agente-en-marcha)).
Ejecútalo primero, antes de cualquier método de instalación.

> **Las opciones tienen variables de entorno**
>
> `--router`, `--ssh-port`, `--ssh-key`, `--arch` y las demás opciones de conexión y de nombres toman
> su valor por defecto de una variable `MIKROSCOPE_*`, así que un intérprete que las exporte convierte
> la orden de arriba en `mikroscope doctor`; `--rate`, `--buffer`, `--port` y los demás ajustes del
> agente no, y hay que pasarlos cada vez. [Variables de entorno](https://docs.jmrp.io/mikroscope/es/reference/environment/) es la lista, y
> el [`.env.example`](https://github.com/jmrplens/mikroscope/blob/main/.env.example) del repositorio es una plantilla.

## Véase también

- [Requisitos](https://docs.jmrp.io/mikroscope/es/install/prerequisites/): los requisitos en el
  equipo, y la tabla de arquitecturas **del router**.
- [Instalar con la CLI](https://docs.jmrp.io/mikroscope/es/install/): lo que hace `install` una vez
  tienes la CLI.
- [Métodos de instalación](https://docs.jmrp.io/mikroscope/es/install/routes/): las otras formas de
  poner el agente en el router.
- [CLI](https://docs.jmrp.io/mikroscope/es/reference/cli/): cada verbo y cada opción.