astra/ntfy
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

all md files translated to spanish

Browse source 
Signed-off-by: felipe <ingenierofelipeurrego@gmail.com>
This commit is contained in:
felipe 2022-06-23 22:14:35 -05:00
parent bac5e1fa84
commit 6fe00ca4d9
15 changed files with 8574 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

968
docs/config-es.md Normal file
View file

@ -0,0 +1,968 @@
# Configuración del servidor ntfy
El servidor ntfy se puede configurar de tres maneras: utilizando un archivo de configuración (normalmente en `/etc/ntfy/server.yml`,
ver [servidor.yml](https://github.com/binwiederhier/ntfy/blob/main/server/server.yml)), a través de argumentos de línea de comandos
o utilizando variables de entorno.
## Inicio rápido
De forma predeterminada, simplemente ejecutando `ntfy serve` iniciará el servidor en el puerto 80. No se necesita configuración. Baterías incluidas 😀.
Si todo funciona como debería, verás algo como esto:
$ ntfy serve
2021/11/30 19:59:08 Listening on :80
Puede comenzar inmediatamente [publicar mensajes](publish.md), o suscríbase a través del [Aplicación para Android](subscribe/phone.md),
[la interfaz de usuario web](subscribe/web.md), o simplemente a través de [curl o tu cliente HTTP favorito](subscribe/api.md). Para configurar
el servidor además, echa un vistazo a la [Tabla de opciones de configuración](#config-options) o simplemente escriba `ntfy serve --help` Para
obtener una lista de [opciones de línea de comandos](#command-line-options).
## Ejemplo de configuración
!!! información
Definitivamente echa un vistazo al **[servidor.yml](https://github.com/binwiederhier/ntfy/blob/main/server/server.yml)** archivo.
Contiene ejemplos y descripciones detalladas de todas las configuraciones.
Los ajustes más básicos son `base-url` (la URL externa del servidor ntfy), la dirección de escucha HTTP/HTTPS (`listen-http`
y `listen-https`), y ruta de acceso de socket (`listen-unix`). Todas las demás cosas son características adicionales.
Aquí hay algunas configuraciones de ejemplo que funcionan:
\=== "server.yml (sólo HTTP, con caché + archivos adjuntos)"
` yaml
base-url: "http://ntfy.example.com"
cache-file: "/var/cache/ntfy/cache.db"
attachment-cache-dir: "/var/cache/ntfy/attachments"
`
\=== "server.yml (HTTP+HTTPS, con caché + adjuntos)"
` yaml
base-url: "http://ntfy.example.com"
listen-http: ":80"
listen-https: ":443"
key-file: "/etc/letsencrypt/live/ntfy.example.com.key"
cert-file: "/etc/letsencrypt/live/ntfy.example.com.crt"
cache-file: "/var/cache/ntfy/cache.db"
attachment-cache-dir: "/var/cache/ntfy/attachments"
`
\=== "server.yml (ntfy.sh config)"
''' yaml
\# Todas las cosas: Detrás de un proxy, Firebase, caché, archivos adjuntos,
\# Publicación y recepción SMTP
base-url: "https://ntfy.sh"
listen-http: "127.0.0.1:2586"
firebase-key-file: "/etc/ntfy/firebase.json"
cache-file: "/var/cache/ntfy/cache.db"
behind-proxy: true
attachment-cache-dir: "/var/cache/ntfy/attachments"
smtp-sender-addr: "email-smtp.us-east-2.amazonaws.com:587"
smtp-sender-user: "AKIDEADBEEFAFFE12345"
smtp-sender-pass: "Abd13Kf+sfAk2DzifjafldkThisIsNotARealKeyOMG."
smtp-sender-from: "ntfy@ntfy.sh"
smtp-server-listen: ":25"
smtp-server-domain: "ntfy.sh"
smtp-server-addr-prefix: "ntfy-"
keepalive-interval: "45s"
```
## Caché de mensajes
Si lo desea, ntfy puede mantener temporalmente las notificaciones en una memoria memoria o en una memoria caché en disco. Almacenamiento en caché de mensajes durante un período corto
del tiempo es importante permitir [Teléfonos](subscribe/phone.md) y otros dispositivos con conexiones a Internet frágiles para poder recuperar
notificaciones que pueden haberse perdido.
De forma predeterminada, ntfy mantiene los mensajes **en memoria durante 12 horas**, lo que significa que **Los mensajes almacenados en caché no sobreviven a una aplicación
reanudar**. Puede invalidar este comportamiento mediante la siguiente configuración:
* `cache-file`: si se establece, ntfy almacenará los mensajes en una memoria caché basada en SQLite (el valor predeterminado es vacío, lo que significa caché en memoria).
**Esto es necesario si desea que los mensajes se conserven durante los reinicios**.
* `cache-duration`: define la duración durante la cual se almacenan los mensajes en la memoria caché (el valor predeterminado es `12h`).
También puede deshabilitar completamente la caché configurando `cache-duration` Para `0`. Cuando la memoria caché está deshabilitada, los mensajes son sólo
se transmite a los suscriptores conectados, pero nunca se almacena en el disco o incluso se mantiene en la memoria más tiempo del necesario para reenviar
el mensaje a los suscriptores.
Los suscriptores pueden recuperar mensajes almacenados en caché mediante el [`poll=1` parámetro](subscribe/api.md#poll-for-messages), así como el
[`since=` parámetro](subscribe/api.md#fetch-cached-messages).
## Accesorios
Si lo desea, puede permitir que los usuarios carguen y [adjuntar archivos a las notificaciones](publish.md#attachments). Para habilitar
En esta característica, simplemente debe configurar un directorio de caché de datos adjuntos y una URL base (`attachment-cache-dir`, `base-url`).
Una vez que se establecen estas opciones y el usuario del servidor puede escribir el directorio, puede cargar archivos adjuntos a través de PUT.
De forma predeterminada, los datos adjuntos se almacenan en la memoria caché de disco **por solo 3 horas**. La razón principal de esto es evitar problemas legales.
y tales cuando se aloja contenido controlado por el usuario. Por lo general, este es un tiempo más que suficiente para el usuario (o la descarga automática)
feature) para descargar el archivo. Las siguientes opciones de configuración son relevantes para los datos adjuntos:
* `base-url` es la URL raíz del servidor ntfy; Esto es necesario para las direcciones URL de datos adjuntos generadas
* `attachment-cache-dir` es el directorio de caché de los archivos adjuntos
* `attachment-total-size-limit` es el límite de tamaño de la caché de datos adjuntos en disco (predeterminado: 5G)
* `attachment-file-size-limit` es el límite de tamaño de datos adjuntos por archivo (por ejemplo, 300k, 2M, 100M, predeterminado: 15M)
* `attachment-expiry-duration` es la duración después de la cual se eliminarán los archivos adjuntos cargados (por ejemplo, 3h, 20h, valor predeterminado: 3h)
Aquí hay un ejemplo de configuración que utiliza principalmente los valores predeterminados (excepto el directorio de caché, que está vacío de forma predeterminada):
\=== "/etc/ntfy/server.yml (mínimo)"
` yaml
base-url: "https://ntfy.sh"
attachment-cache-dir: "/var/cache/ntfy/attachments"
`
\=== "/etc/ntfy/server.yml (todas las opciones)"
` yaml
base-url: "https://ntfy.sh"
attachment-cache-dir: "/var/cache/ntfy/attachments"
attachment-total-size-limit: "5G"
attachment-file-size-limit: "15M"
attachment-expiry-duration: "3h"
visitor-attachment-total-size-limit: "100M"
visitor-attachment-daily-bandwidth-limit: "500M"
`
Por favor, consulte también el [limitación de velocidad](#rate-limiting) configuración a continuación, específicamente `visitor-attachment-total-size-limit`
y `visitor-attachment-daily-bandwidth-limit`. Establecerlos de manera conservadora es necesario para evitar el abuso.
## Control de acceso
De forma predeterminada, el servidor ntfy está abierto para todos, lo que significa **todo el mundo puede leer y escribir sobre cualquier tema** (así es como
ntfy.sh está configurado). Para restringir el acceso a su propio servidor, puede configurar opcionalmente la autenticación y la autorización.
La autenticación de ntfy se implementa con un simple [SQLite](https://www.sqlite.org/)-backend basado. Implementa dos roles
(`user` y `admin`) y por tema `read` y `write` permisos mediante un [lista de control de acceso (ACL)](https://en.wikipedia.org/wiki/Access-control_list).
Las entradas de control de acceso se pueden aplicar a los usuarios, así como al usuario especial de todos (`*`), que representa el acceso anónimo a la API.
Para configurar la autenticación, simplemente **Configure las dos opciones siguientes**:
* `auth-file` es la base de datos de usuario/acceso; se crea automáticamente si aún no existe; propuesto
ubicación `/var/lib/ntfy/user.db` (más fácil si se utiliza el paquete deb/rpm)
* `auth-default-access` define el acceso predeterminado/de reserva si no se encuentra ninguna entrada de control de acceso; puede ser
establecer en `read-write` (por defecto), `read-only`, `write-only` o `deny-all`.
Una vez configurado, puede utilizar el `ntfy user` comando a [agregar o modificar usuarios](#users-and-roles), y el `ntfy access` mandar
le permite [Modificar la lista de control de acceso](#access-control-list-acl) para usuarios específicos y patrones de temas. Ambos
Comandos **Edite directamente la base de datos de autenticación** (tal como se define en `auth-file`), por lo que solo funcionan en el servidor, y solo si el usuario
acceder a ellos tiene los permisos correctos.
### Usuarios y roles
El `ntfy user` Le permite agregar,quitar/cambiar usuarios en la base de datos de usuarios de Ntfy, así como cambiar
contraseñas o roles (`user` o `admin`). En la práctica, a menudo solo creará un administrador
usuario con `ntfy user add --role=admin ...` y hágase con todo esto (ver [ejemplo a continuación](#example-private-instance)).
**Papeles:**
* Rol `user` (predeterminado): los usuarios con este rol no tienen permisos especiales. Administrar el acceso mediante `ntfy access`
(ver [abajo](#access-control-list-acl)).
* Rol `admin`: Los usuarios con este rol pueden leer/escribir en todos los temas. El control de acceso granular no es necesario.
**Comandos de ejemplo** (tipo `ntfy user --help` o `ntfy user COMMAND --help` para más detalles):
ntfy user list # Shows list of users (alias: 'ntfy access')
ntfy user add phil # Add regular user phil
ntfy user add --role=admin phil # Add admin user phil
ntfy user del phil # Delete user phil
ntfy user change-pass phil # Change password for user phil
ntfy user change-role phil admin # Make user phil an admin
### Lista de control de acceso (ACL)
La lista de control de acceso (ACL) **administra el acceso a los temas para los usuarios que no son administradores y para el acceso anónimo (`everyone`/`*`)**.
Cada entrada representa los permisos de acceso de un usuario a un tema o patrón de tema específico.
La ACL se puede mostrar o modificar con el `ntfy access` mandar:
ntfy access # Shows access control list (alias: 'ntfy user list')
ntfy access USERNAME # Shows access control entries for USERNAME
ntfy access USERNAME TOPIC PERMISSION # Allow/deny access for USERNAME to TOPIC
Un `USERNAME` es un usuario existente, tal como se creó con `ntfy user add` (ver [usuarios y roles](#users-and-roles)), o el
usuario anónimo `everyone` o `*`, que representa a los clientes que acceden a la API sin nombre de usuario/contraseña.
Un `TOPIC` es un nombre de tema específico (por ejemplo, `mytopic`o `phil_alerts`), o un patrón comodín que coincida con cualquier
número de temas (por ejemplo, `alerts_*` o `ben-*`). Sólo el carácter comodín `*` es compatible. Significa cero a cualquier
número de caracteres.
Un `PERMISSION` es cualquiera de los siguientes permisos admitidos:
* `read-write` (alias: `rw`): Permite [publicar mensajes](publish.md) al tema dado, así como
[Suscribirse](subscribe/api.md) y lectura de mensajes
* `read-only` (alias: `read`, `ro`): Permite solo suscribirse y leer mensajes, pero no publicar en el tema
* `write-only` (alias: `write`, `wo`): Permite publicar solo en el tema, pero no suscribirse a él
* `deny` (alias: `none`): No permite publicar ni suscribirse a un tema
**Comandos de ejemplo** (tipo `ntfy access --help` para más detalles):
ntfy access # Shows entire access control list
ntfy access phil # Shows access for user phil
ntfy access phil mytopic rw # Allow read-write access to mytopic for user phil
ntfy access everyone mytopic rw # Allow anonymous read-write access to mytopic
ntfy access everyone "up*" write # Allow anonymous write-only access to topics "up..."
ntfy access --reset # Reset entire access control list
ntfy access --reset phil # Reset all access for user phil
ntfy access --reset phil mytopic # Reset access for user phil and topic mytopic
**Ejemplo de ACL:**
$ ntfy access
user phil (admin)
- read-write access to all topics (admin role)
user ben (user)
- read-write access to topic garagedoor
- read-write access to topic alerts*
- read-only access to topic furnace
user * (anonymous)
- read-only access to topic announcements
- read-only access to topic server-stats
- no access to any (other) topics (server config)
En este ejemplo, `phil` tiene el rol `admin`, por lo que tiene acceso de lectura y escritura a todos los temas (no se necesitan entradas de ACL).
Usuario `ben` tiene tres entradas específicas del tema. Puede leer, pero no escribir sobre el tema `furnace`, y tiene acceso de lectura y escritura
al tema `garagedoor` y todos los temas que comienzan con la palabra `alerts` (comodines). Clientes que no están autenticados
(llamado `*`/`everyone`) sólo tienen acceso de lectura a la `announcements` y `server-stats` Temas.
### Ejemplo: Instancia privada
La forma más sencilla de configurar una instancia privada es establecer `auth-default-access` Para `deny-all` En `server.yml`:
\=== "/etc/ntfy/server.yml"
` yaml
auth-file: "/var/lib/ntfy/user.db"
auth-default-access: "deny-all"
`
Después de eso, simplemente cree un `admin` usuario:
$ ntfy user add --role=admin phil
password: mypass
confirm: mypass
user phil added with role admin
Una vez que haya hecho eso, puede publicar y suscribirse usando [Autenticación básica](https://en.wikipedia.org/wiki/Basic_access_authentication)
con el nombre de usuario/contraseña dado. Asegúrese de usar HTTPS para evitar espiar y exponer su contraseña. Aquí hay un ejemplo simple:
\=== "Línea de comandos (curl)"
` curl \ -u phil:mypass \ -d "Look ma, with auth" \
https://ntfy.example.com/mysecrets
`
\=== "ntfy CLI"
` ntfy publish \ -u phil:mypass \
ntfy.example.com/mysecrets \
"Look ma, with auth"
`
\=== "HTTP"
''' http
POST /mysecrets HTTP/1.1
Anfitrión: ntfy.example.com
Autorización: Basic cGhpbDpteXBhc3M=
Look ma, with auth
```
\=== "JavaScript"
` javascript
fetch('https://ntfy.example.com/mysecrets', {
method: 'POST', // PUT works too
body: 'Look ma, with auth',
headers: {
'Authorization': 'Basic cGhpbDpteXBhc3M='
}
})
`
\=== "Go"
` go
req, _ := http.NewRequest("POST", "https://ntfy.example.com/mysecrets",
strings.NewReader("Look ma, with auth"))
req.Header.Set("Authorization", "Basic cGhpbDpteXBhc3M=")
http.DefaultClient.Do(req)
`
\=== "Python"
` python
requests.post("https://ntfy.example.com/mysecrets",
data="Look ma, with auth",
headers={
"Authorization": "Basic cGhpbDpteXBhc3M="
})
`
\=== "PHP"
` php-inline
file_get_contents('https://ntfy.example.com/mysecrets', false, stream_context_create([
'http' => [
'method' => 'POST', // PUT also works
'header' =>
'Content-Type: text/plain\r\n' .
'Authorization: Basic cGhpbDpteXBhc3M=',
'content' => 'Look ma, with auth'
]
]));
`
## Notificaciones por correo electrónico
Para permitir el reenvío de mensajes por correo electrónico, puede configurar un **Servidor SMTP para mensajes salientes**. Una vez configurado,
Puede establecer el `X-Email` encabezado a [enviar mensajes por correo electrónico](publish.md#e-mail-notifications) (por ejemplo,
`curl -d "hi there" -H "X-Email: phil@example.com" ntfy.sh/mytopic`).
A partir de hoy, solo se admiten servidores SMTP con autenticación PLAIN y STARTLS. Para habilitar el envío de correo electrónico, debe establecer el
siguientes configuraciones:
* `base-url` es la URL raíz del servidor ntfy; Esto es necesario para el pie de página del correo electrónico
* `smtp-sender-addr` es el nombre de host:puerto del servidor SMTP
* `smtp-sender-user` y `smtp-sender-pass` son el nombre de usuario y la contraseña del usuario SMTP
* `smtp-sender-from` es la dirección de correo electrónico del remitente
Aquí hay un ejemplo de configuración usando [Amazon SES](https://aws.amazon.com/ses/) para el correo saliente (así es como es
configurado para `ntfy.sh`):
\=== "/etc/ntfy/server.yml"
` yaml
base-url: "https://ntfy.sh"
smtp-sender-addr: "email-smtp.us-east-2.amazonaws.com:587"
smtp-sender-user: "AKIDEADBEEFAFFE12345"
smtp-sender-pass: "Abd13Kf+sfAk2DzifjafldkThisIsNotARealKeyOMG."
smtp-sender-from: "ntfy@ntfy.sh"
`
Por favor, consulte también el [limitación de velocidad](#rate-limiting) configuración a continuación, específicamente `visitor-email-limit-burst`
y `visitor-email-limit-burst`. Establecerlos de manera conservadora es necesario para evitar el abuso.
## Publicación de correo electrónico
Para permitir la publicación de mensajes por correo electrónico, ntfy puede ejecutar un **Servidor SMTP para mensajes entrantes**. Una vez configurado,
los usuarios pueden [enviar correos electrónicos a una dirección de correo electrónico de tema](publish.md#e-mail-publishing) (por ejemplo, `mytopic@ntfy.sh` o
`myprefix-mytopic@ntfy.sh`) para publicar mensajes en un tema. Esto es útil para integraciones basadas en correo electrónico, como
statuspage.io (aunque en estos días la mayoría de los servicios también admiten webhooks y llamadas HTTP).
Para configurar el servidor SMTP, debe al menos establecer `smtp-server-listen` y `smtp-server-domain`:
* `smtp-server-listen` define la dirección IP y el puerto en el que escuchará el servidor SMTP, por ejemplo. `:25` o `1.2.3.4:25`
* `smtp-server-domain` es el dominio de correo electrónico, por ejemplo. `ntfy.sh` (debe ser idéntico al registro MX, ver más abajo)
* `smtp-server-addr-prefix` es un prefijo opcional para las direcciones de correo electrónico para evitar el spam. Si se establece en `ntfy-`por ejemplo
sólo envía correos electrónicos a `ntfy-$topic@ntfy.sh` será aceptado. Si esto no está configurado, todos los correos electrónicos a `$topic@ntfy.sh` será
aceptado (que obviamente puede ser un problema de spam).
Aquí hay una configuración de ejemplo (así es como se configura para `ntfy.sh`):
\=== "/etc/ntfy/server.yml"
` yaml
smtp-server-listen: ":25"
smtp-server-domain: "ntfy.sh"
smtp-server-addr-prefix: "ntfy-"
`
Además de configurar el servidor ntfy, debe crear dos registros DNS (un [Registro MX](https://en.wikipedia.org/wiki/MX_record)
y un registro A correspondiente), por lo que el correo entrante llegará a su servidor. Aquí hay un ejemplo de cómo `ntfy.sh` es
configurado (en [Ruta de Amazon 53](https://aws.amazon.com/route53/)):
<figure markdown>
![DNS records for incoming mail](static/img/screenshot-email-publishing-dns.png){ width=600 }
<figcaption>DNS records for incoming mail</figcaption>
</figure>
Puede verificar si todo funciona correctamente enviando un correo electrónico como SMTP sin procesar a través de `nc`. Crear un archivo de texto, por ejemplo.
`email.txt`
EHLO example.com
MAIL FROM: phil@example.com
RCPT TO: ntfy-mytopic@ntfy.sh
DATA
Subject: Email for you
Content-Type: text/plain; charset="UTF-8"
Hello from 🇩🇪
.
Y luego enviar el correo a través de `nc` Así. Si ve alguna línea que comience por `451`, esos son errores de la
Servidor ntfy. Léalos detenidamente.
$ cat email.txt | nc -N ntfy.sh 25
220 ntfy.sh ESMTP Service Ready
250-Hello example.com
...
250 2.0.0 Roger, accepting mail from <phil@example.com>
250 2.0.0 I'll make sure <ntfy-mytopic@ntfy.sh> gets this
En cuanto a la configuración de DNS, asegúrese de verificar que `dig MX` y `dig A` están devolviendo resultados similares a este:
$ dig MX ntfy.sh +short
10 mx1.ntfy.sh.
$ dig A mx1.ntfy.sh +short
3.139.215.220
## Detrás de un proxy (TLS, etc.)
!!! advertencia
Si está ejecutando ntfy detrás de un proxy, debe establecer el `behind-proxy` bandera. De lo contrario, todos los visitantes son
[tarifa limitada](#rate-limiting) como si fueran uno.
Puede ser deseable ejecutar ntfy detrás de un proxy (por ejemplo, nginx, HAproxy o Apache), para que pueda proporcionar certificados TLS
usando Let's Encrypt usando certbot, o simplemente porque desea compartir los puertos (80/443) con otros servicios.
Cualesquiera que sean sus razones, hay algunas cosas a considerar.
Si está ejecutando ntfy detrás de un proxy, debe establecer el `behind-proxy` bandera. Esto instruirá al
[limitación de velocidad](#rate-limiting) lógica para utilizar el `X-Forwarded-For` encabezado como identificador principal para un visitante,
a diferencia de la dirección IP remota. Si el `behind-proxy` la bandera no está configurada, todos los visitantes lo harán
se cuentan como uno, porque desde la perspectiva del servidor ntfy, todos comparten la dirección IP del proxy.
\=== "/etc/ntfy/server.yml"
` yaml # Tell ntfy to use "X-Forwarded-For" to identify visitors
behind-proxy: true
`
### TLS/SSL
Ntfy admite HTTPS/TLS estableciendo el `listen-https` [opción de configuración](#config-options). Sin embargo, si usted
están detrás de un proxy, se recomienda que la terminación TLS / SSL sea realizada por el propio proxy (ver más abajo).
Recomiendo encarecidamente usar [certbot](https://certbot.eff.org/). Lo uso con el [Complemento dns-route53](https://certbot-dns-route53.readthedocs.io/en/stable/),
que le permite usar [Ruta 53 de AWS](https://aws.amazon.com/route53/) como el reto. Eso es mucho más fácil que usar el
Desafío HTTP. He encontrado [esta guía](https://nandovieira.com/using-lets-encrypt-in-development-with-nginx-and-aws-route53) Para
ser increíblemente útil.
### nginx/Apache2/caddy
Para su comodidad, aquí hay una configuración de trabajo que ayudará a configurar las cosas detrás de un proxy. Asegúrese de **habilitar WebSockets**
reenviando el `Connection` y `Upgrade` encabezados en consecuencia.
En este ejemplo, ntfy se ejecuta en `:2586` y le enviamos el tráfico. También redirigimos HTTP a HTTPS para solicitudes GET contra un tema
o el dominio raíz:
\=== "nginx (/etc/nginx/sites-\*/ntfy)"
\`\`\`
servidor {
escuchar 80;
server_name ntfy.sh;
location / {
# Redirect HTTP to HTTPS, but only for GET topic addresses, since we want
# it to work with curl without the annoying https:// prefix
set $redirect_https "";
if ($request_method = GET) {
set $redirect_https "yes";
}
if ($request_uri ~* "^/([-_a-z0-9]{0,64}$|docs/|static/)") {
set $redirect_https "${redirect_https}yes";
}
if ($redirect_https = "yesyes") {
return 302 https://$http_host$request_uri$is_args$query_string;
}
proxy_pass http://127.0.0.1:2586;
proxy_http_version 1.1;
proxy_buffering off;
proxy_request_buffering off;
proxy_redirect off;
proxy_set_header Host $http_host;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_connect_timeout 3m;
proxy_send_timeout 3m;
proxy_read_timeout 3m;
client_max_body_size 20m; # Must be >= attachment-file-size-limit in /etc/ntfy/server.yml
}
}
server {
listen 443 ssl;
server_name ntfy.sh;
ssl_session_cache builtin:1000 shared:SSL:10m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers HIGH:!aNULL:!eNULL:!EXPORT:!CAMELLIA:!DES:!MD5:!PSK:!RC4;
ssl_prefer_server_ciphers on;
ssl_certificate /etc/letsencrypt/live/ntfy.sh/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/ntfy.sh/privkey.pem;
location / {
proxy_pass http://127.0.0.1:2586;
proxy_http_version 1.1;
proxy_buffering off;
proxy_request_buffering off;
proxy_redirect off;
proxy_set_header Host $http_host;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_connect_timeout 3m;
proxy_send_timeout 3m;
proxy_read_timeout 3m;
client_max_body_size 20m; # Must be >= attachment-file-size-limit in /etc/ntfy/server.yml
}
}
```
\=== "Apache2 (/etc/apache2/sites-\*/ntfy.conf)"
\`\`\`
\<VirtualHost \*:80>
ServerName ntfy.sh
# Proxy connections to ntfy (requires "a2enmod proxy")
ProxyPass / http://127.0.0.1:2586/
ProxyPassReverse / http://127.0.0.1:2586/
SetEnv proxy-nokeepalive 1
SetEnv proxy-sendchunked 1
# Higher than the max message size of 4096 bytes
LimitRequestBody 102400
# Enable mod_rewrite (requires "a2enmod rewrite")
RewriteEngine on
# WebSockets support (requires "a2enmod rewrite proxy_wstunnel")
RewriteCond %{HTTP:Upgrade} websocket [NC]
RewriteCond %{HTTP:Connection} upgrade [NC]
RewriteRule ^/?(.*) "ws://127.0.0.1:2586/$1" [P,L]
# Redirect HTTP to HTTPS, but only for GET topic addresses, since we want
# it to work with curl without the annoying https:// prefix
RewriteCond %{REQUEST_METHOD} GET
RewriteRule ^/([-_A-Za-z0-9]{0,64})$ https://%{SERVER_NAME}/$1 [R,L]
</VirtualHost>
<VirtualHost *:443>
ServerName ntfy.sh
SSLEngine on
SSLCertificateFile /etc/letsencrypt/live/ntfy.sh/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/ntfy.sh/privkey.pem
Include /etc/letsencrypt/options-ssl-apache.conf
# Proxy connections to ntfy (requires "a2enmod proxy")
ProxyPass / http://127.0.0.1:2586/
ProxyPassReverse / http://127.0.0.1:2586/
SetEnv proxy-nokeepalive 1
SetEnv proxy-sendchunked 1
# Higher than the max message size of 4096 bytes
LimitRequestBody 102400
# Enable mod_rewrite (requires "a2enmod rewrite")
RewriteEngine on
# WebSockets support (requires "a2enmod rewrite proxy_wstunnel")
RewriteCond %{HTTP:Upgrade} websocket [NC]
RewriteCond %{HTTP:Connection} upgrade [NC]
RewriteRule ^/?(.*) "ws://127.0.0.1:2586/$1" [P,L]
</VirtualHost>
```
\=== "caddy"
\`\`\`
\# Tenga en cuenta que esta configuración es ciertamente incompleta. Por favor, ayúdame y hazme saber lo que falta
\# a través de Discord/Matrix o en un problema de GitHub.
ntfy.sh, http://nfty.sh {
reverse_proxy 127.0.0.1:2586
# Redirect HTTP to HTTPS, but only for GET topic addresses, since we want
# it to work with curl without the annoying https:// prefix
@httpget {
protocol http
method GET
path_regexp ^/([-_a-z0-9]{0,64}$|docs/|static/)
}
redir @httpget https://{host}{uri}
}
```
## Base de fuego (FCM)
!!! información
El uso de Firebase es **opcional** y solo funciona si modifica y [crea tu propio .apk Android](develop.md#android-app).
Para una instancia autohospedada, es más fácil simplemente no molestarse con FCM.
[Mensajería en la nube de Firebase (FCM)](https://firebase.google.com/docs/cloud-messaging) es la forma aprobada por Google para enviar
enviar mensajes a dispositivos Android. FCM es el único método que una aplicación de Android puede recibir mensajes sin tener que ejecutar un
[servicio en primer plano](https://developer.android.com/guide/components/foreground-services).
Para el host principal [ntfy.sh](https://ntfy.sh)el [Aplicación ntfy para Android](subscribe/phone.md) utiliza Firebase para enviar mensajes
al dispositivo. Para otros hosts, se utiliza la entrega instantánea y FCM no está involucrado.
Para configurar FCM para la instancia autohospedada del servidor ntfy, siga estos pasos:
1. Regístrese para un [Cuenta de Firebase](https://console.firebase.google.com/)
2. Crea una aplicación de Firebase y descarga el archivo de claves (por ejemplo, `myapp-firebase-adminsdk-...json`)
3. Coloque el archivo de clave en `/etc/ntfy`, establezca el `firebase-key-file` en `server.yml` en consecuencia, reinicie el servidor NTFY
4. Crea tu propio Android .apk siguiente [Estas instrucciones](develop.md#android-app)
Ejemplo:
# If set, also publish messages to a Firebase Cloud Messaging (FCM) topic for your app.
# This is optional and only required to support Android apps (which don't allow background services anymore).
#
firebase-key-file: "/etc/ntfy/ntfy-sh-firebase-adminsdk-ahnce-9f4d6f14b5.json"
## Notificaciones instantáneas de iOS
A diferencia de Android, iOS restringe en gran medida el procesamiento en segundo plano, lo que lamentablemente hace que sea imposible implementar el procesamiento instantáneo.
notificaciones push sin un servidor central.
Para seguir admitiendo notificaciones instantáneas en iOS a través de su servidor ntfy autohospedado, debe reenviar los llamados `poll_request`
mensajes al servidor principal de ntfy.sh (o a cualquier servidor ascendente que esté conectado a APNS/Firebase, si creas tu propia aplicación iOS),
que luego lo reenviará a Firebase/APNS.
Para configurarlo, simplemente configure `upstream-base-url` de esta manera:
```yaml
upstream-base-url: "https://ntfy.sh"
```
Si se establece, todos los mensajes entrantes publicarán una solicitud de sondeo en el servidor ascendente configurado, que contiene
el identificador de mensaje del mensaje original, que indica a la aplicación iOS que sondee este servidor en busca del contenido real del mensaje.
Si `upstream-base-url` no está configurado, las notificaciones llegarán eventualmente a su dispositivo, pero la entrega puede tardar horas,
dependiendo del estado del teléfono. Sin embargo, si está usando su teléfono, no debería tomar más de 20-30 minutos.
En caso de que tengas curiosidad, aquí hay un ejemplo de todo el flujo:
* En la aplicación iOS, te suscribes a `https://ntfy.example.com/mytopic`
* La aplicación se suscribe al tema de Firebase `6de73be8dfb7d69e...` (el SHA256 de la URL del tema)
* Al publicar un mensaje en `https://ntfy.example.com/mytopic`, el servidor NTFY publicará un
solicitud de sondeo a `https://ntfy.sh/6de73be8dfb7d69e...`. La solicitud de su servidor al servidor ascendente
contiene sólo el identificador de mensaje (en el cuadro de diálogo `X-Poll-ID` encabezado), y la suma de comprobación SHA256 de la dirección URL del tema (como tema ascendente).
* El servidor de ntfy.sh publica el mensaje de solicitud de sondeo en Firebase, que lo reenvía a APNS, que lo reenvía a tu dispositivo iOS.
* Su dispositivo iOS recibe la solicitud de sondeo y obtiene el mensaje real de su servidor y, a continuación, lo muestra
Aquí hay un ejemplo de lo que el servidor autohospedado reenvía al servidor ascendente. La solicitud es equivalente a este rizo:
curl -X POST -H "X-Poll-ID: s4PdJozxM8na" https://ntfy.sh/6de73be8dfb7d69e32fb2c00c23fe7adbd8b5504406e3068c273aa24cef4055b
{"id":"4HsClFEuCIcs","time":1654087955,"event":"poll_request","topic":"6de73be8dfb7d69e32fb2c00c23fe7adbd8b5504406e3068c273aa24cef4055b","message":"New message","poll_id":"s4PdJozxM8na"}
## Limitación de velocidad
!!! información
Tenga en cuenta que si está ejecutando ntfy detrás de un proxy, debe establecer el `behind-proxy` bandera.
De lo contrario, todos los visitantes están limitados por la tarifa como si fueran uno.
De forma predeterminada, ntfy se ejecuta sin autenticación, por lo que es de vital importancia que protejamos el servidor del abuso o la sobrecarga.
Existen varios límites y límites de velocidad que puede utilizar para configurar el servidor:
* **Límite global**: Se aplica un límite global a todos los visitantes (IP, clientes, usuarios)
* **Límite de visitantes**: Un límite de visitantes solo se aplica a un determinado visitante. Un **visitante** se identifica por su dirección IP
(o el `X-Forwarded-For` encabezado si `behind-proxy` está configurado). Todas las opciones de configuración que comienzan con la palabra `visitor` aplicar
solo por visitante.
Durante el uso normal, no debería encontrar estos límites en absoluto, e incluso si revienta algunas solicitudes o correos electrónicos.
(por ejemplo, cuando se vuelve a conectar después de una caída de la conexión), no debería tener ningún efecto.
### Límites generales
Hagamos primero los límites fáciles:
* `global-topic-limit` define el número total de temas antes de que el servidor rechace nuevos temas. El valor predeterminado es 15.000.
* `visitor-subscription-limit` es el número de suscripciones (conexiones abiertas) por visitante. Este valor predeterminado es 30.
### Límites de solicitud
Además de los límites anteriores, hay un límite de solicitudes / segundo por visitante para todas las solicitudes sensibles GET / PUT / POST.
Este límite utiliza un [bucket de tokens](https://en.wikipedia.org/wiki/Token_bucket) (usando Go's [paquete de tarifas](https://pkg.go.dev/golang.org/x/time/rate)):
Cada visitante tiene un bucket de 60 solicitudes que pueden disparar contra el servidor (definidas por `visitor-request-limit-burst`).
Después de los 60, las nuevas solicitudes se encontrarán con un `429 Too Many Requests` respuesta. El cubo de solicitud de visitante se rellena a una velocidad de uno
solicitud cada 5s (definida por `visitor-request-limit-replenish`)
* `visitor-request-limit-burst` es el cubo inicial de solicitudes que tiene cada visitante. El valor predeterminado es 60.
* `visitor-request-limit-replenish` es la velocidad a la que se rellena el bucket (una solicitud por x). El valor predeterminado es 5s.
* `visitor-request-limit-exempt-hosts` es una lista separada por comas de nombres de host e IP que deben estar exentos de la tasa de solicitud
limitante; los nombres de host se resuelven en el momento en que se inicia el servidor. El valor predeterminado es una lista vacía.
### Límites de datos adjuntos
Aparte del tamaño global del archivo y los límites totales de caché de datos adjuntos (consulte [encima](#attachments)), hay dos relevantes
Límites por visitante:
* `visitor-attachment-total-size-limit` es el límite total de almacenamiento utilizado para los archivos adjuntos por visitante. El valor predeterminado es 100M.
El almacenamiento por visitante se reduce automáticamente a medida que expiran los archivos adjuntos. Accesorios externos (conectados a través de `X-Attach`,
ver [publicar documentos](publish.md#attachments)) no cuentan aquí.
* `visitor-attachment-daily-bandwidth-limit` es el límite total diario de ancho de banda de descarga/carga de archivos adjuntos por visitante,
incluidas las solicitudes PUT y GET. Esto es para proteger su valioso ancho de banda del abuso, ya que la salida cuesta dinero en
la mayoría de los proveedores de nube. El valor predeterminado es 500M.
### Límites de correo electrónico
De manera similar al límite de solicitudes, también hay un límite de correo electrónico (solo relevante si [notificaciones por correo electrónico](#e-mail-notifications)
están habilitados):
* `visitor-email-limit-burst` es el cubo inicial de correos electrónicos que tiene cada visitante. El valor predeterminado es 16.
* `visitor-email-limit-replenish` es la velocidad a la que se rellena el bucket (un correo electrónico por x). El valor predeterminado es 1h.
### Límites de Firebase
Si [Firebase está configurado](#firebase-fcm), todos los mensajes también se publican en un tema de Firebase (a menos que `Firebase: no`
está configurado). Firebase aplica [sus propios límites](https://firebase.google.com/docs/cloud-messaging/concept-options#topics_throttling)
sobre cuántos mensajes se pueden publicar. Desafortunadamente, estos límites son un poco vagos y pueden cambiar dependiendo del tiempo.
del día. En la práctica, solo he observado `429 Quota exceeded` respuestas de Firebase si **Se publican demasiados mensajes en
el mismo tema**.
En ntfy, si Firebase responde con un 429 después de publicar en un tema, el visitante (= dirección IP) que publicó el mensaje
es **se prohibió publicar en Firebase durante 10 minutos** (no configurable). Debido a que la publicación en Firebase se realiza de forma asincrónica,
no hay ninguna indicación del usuario de que esto haya sucedido. Los suscriptores que no son de Firebase (WebSocket o HTTP stream) no se ven afectados.
Después de los 10 minutos, se reanuda el reenvío de mensajes a Firebase para este visitante.
Si esto sucede alguna vez, habrá un mensaje de registro que se ve algo como esto:
WARN Firebase quota exceeded (likely for topic), temporarily denying Firebase access to visitor
## Ajuste para escala
Si está ejecutando ntfy para su servidor doméstico, probablemente no tenga que preocuparse por la escala en absoluto. En su configuración predeterminada,
Si no está detrás de un proxy, el servidor NTFY puede mantener aproximadamente **tantas conexiones como permita el límite de archivos abiertos**.
Este límite se suele denominar `nofile`. Aparte de eso, la RAM y la CPU son obviamente relevantes. También es posible que desee verificar
fuera [esta discusión en Reddit](https://www.reddit.com/r/golang/comments/r9u4ee/how_many_actively_connected_http_clients_can_a_go/).
Según *cómo lo ejecuta*, aquí hay algunos límites que son relevantes:
### WAL para caché de mensajes
De forma predeterminada, el [caché de mensajes](#message-cache) (definido por `cache-file`) utiliza la configuración predeterminada de SQLite, lo que significa que
se sincroniza con el disco en cada escritura. Para servidores personales, esto es perfectamente adecuado. Para instalaciones más grandes, como ntfy.sh,
el [registro de escritura anticipada (WAL)](https://sqlite.org/wal.html) debe estar habilitado y el modo de sincronización debe ajustarse.
Ver [este artículo](https://phiresky.github.io/blog/2020/sqlite-performance-tuning/) para más detalles.
Así es como se ha sintonizado ntfy.sh en el `server.yml` archivo:
```yaml
cache-startup-queries: |
pragma journal_mode = WAL;
pragma synchronous = normal;
pragma temp_store = memory;
```
### Para servicios systemd
Si está ejecutando ntfy en un servicio systemd (por ejemplo, para paquetes de .deb/.rpm), el principal factor limitante es el
`LimitNOFILE` en la unidad systemd. El límite predeterminado de archivos abiertos para `ntfy.service` es 10.000. Puede anularlo
mediante la creación de un `/etc/systemd/system/ntfy.service.d/override.conf` archivo. Por lo que puedo decir, `/etc/security/limits.conf`
no es relevante.
\=== "/etc/systemd/system/ntfy.service.d/override.conf"
` # Allow 20,000 ntfy connections (and give room for other file handles) [Service]
LimitNOFILE=20500
`
### Fuera de systemd
Si está ejecutando fuera de systemd, es posible que desee ajustar su `/etc/security/limits.conf` archivo a
aumentar el `nofile` ajuste. Aquí hay un ejemplo que aumenta el límite a 5,000. Puede averiguar la configuración actual
corriendo `ulimit -n`, o anule manualmente temporalmente ejecutando `ulimit -n 50000`.
\=== "/etc/security/limits.conf"
` # Increase open files limit globally * hard nofile 20500
`
### Límites de proxy (nginx, Apache2)
Si estás corriendo [detrás de un proxy](#behind-a-proxy-tls-etc) (por ejemplo, nginx, Apache), el límite de archivos abiertos del proxy también es
pertinente. Entonces, si su proxy se ejecuta dentro de systemd, aumente los límites en systemd para el proxy. Normalmente, el proxy
El límite de archivos abiertos tiene que ser **Duplique el número de conexiones que desea admitir**, porque el proxy tiene
para mantener la conexión del cliente y la conexión con ntfy.
\=== "/etc/nginx/nginx.conf"
` events { # Allow 40,000 proxy connections (2x of the desired ntfy connection count; # and give room for other file handles)
worker_connections 40500;
}
`
\=== "/etc/systemd/system/nginx.service.d/override.conf"
` # Allow 40,000 proxy connections (2x of the desired ntfy connection count; # and give room for other file handles) [Service]
LimitNOFILE=40500
`
### Prohibir a los malos actores (fail2ban)
Si pones cosas en Internet, los malos actores intentarán romperlas o irrumpir. [fail2ban](https://www.fail2ban.org/)
y nginx's [ngx_http_limit_req_module módulo](http://nginx.org/en/docs/http/ngx_http_limit_req_module.html) se puede utilizar
prohibir las IP de los clientes si se comportan mal. Esto está en la parte superior de la [limitación de velocidad](#rate-limiting) dentro del servidor ntfy.
Aquí hay un ejemplo de cómo se configura ntfy.sh, siguiendo las instrucciones de dos tutoriales ([aquí](https://easyengine.io/tutorials/nginx/fail2ban/)
y [aquí](https://easyengine.io/tutorials/nginx/block-wp-login-php-bruteforce-attack/)):
\=== "/etc/nginx/nginx.conf"
` http {
limit_req_zone $binary_remote_addr zone=one:10m rate=1r/s;
}
`
\=== "/etc/nginx/sites-enabled/ntfy.sh"
` # For each server/location block
server {
location / {
limit_req zone=one burst=1000 nodelay;
}
}
`
\=== "/etc/fail2ban/filter.d/nginx-req-limit.conf"
` [Definition]
failregex = limiting requests, excess:.* by zone.*client: <HOST>
ignoreregex =
`
\=== "/etc/fail2ban/jail.local"
` [nginx-req-limit]
enabled = true
filter = nginx-req-limit
action = iptables-multiport[name=ReqLimit, port="http,https", protocol=tcp]
logpath = /var/log/nginx/error.log
findtime = 600
bantime = 7200
maxretry = 10
`
## Depuración/rastreo
Si algo no funciona correctamente, puede depurar / rastrear lo que está haciendo el servidor ntfy configurando el `log-level`
Para `DEBUG` o `TRACE`. El `DEBUG` Establecer generará información sobre cada mensaje publicado, pero no el mensaje
contenido. El `TRACE` también imprimirá el contenido del mensaje.
!!! advertencia
Ambas opciones son muy detalladas y solo deben habilitarse en producción durante cortos períodos de tiempo. De otra manera
te vas a quedar sin espacio en disco bastante rápido.
También puede recargar en caliente el `log-level` enviando el `SIGHUP` señal al proceso después de editar el `server.yml` archivo.
Puedes hacerlo llamando `systemctl reload ntfy` (si ntfy se ejecuta dentro de systemd), o llamando `kill -HUP $(pidof ntfy)`.
Si tiene éxito, verá algo como esto:
$ ntfy serve
2022/06/02 10:29:28 INFO Listening on :2586[http] :1025[smtp], log level is INFO
2022/06/02 10:29:34 INFO Partially hot reloading configuration ...
2022/06/02 10:29:34 INFO Log level is TRACE
## Opciones de configuración
Cada opción de configuración se puede establecer en el archivo de configuración `/etc/ntfy/server.yml` (por ejemplo, `listen-http: :80`) o como
Opción CLI (por ejemplo, `--listen-http :80`. Aquí hay una lista de todas las opciones disponibles. Como alternativa, puede establecer un entorno
antes de ejecutar el `ntfy` comando (por ejemplo, `export NTFY_LISTEN_HTTP=:80`).
!!! información
Todas las opciones de configuración también se pueden definir en el `server.yml` archivo que utiliza guiones bajos en lugar de guiones, por ejemplo.
`cache_duration` y `cache-duration` ambos son compatibles. Esto es para admitir analizadores YAML más estrictos que lo hacen.
no soporta guiones.
| | de opciones de configuración | de variables Env Formato | | predeterminada Descripción |
|--------------------------------------------|-------------------------------------------------|-----------------------------------------------------|-------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `base-url` | `NTFY_BASE_URL` | *URL* | - | URL base pública del servicio (por ejemplo, `https://ntfy.sh`) |
| `listen-http` | `NTFY_LISTEN_HTTP` | `[host]:port` | `:80` | Dirección de escucha para el servidor web HTTP |
| `listen-https` | `NTFY_LISTEN_HTTPS` | `[host]:port` | - | Dirección de escucha para el servidor web HTTPS. Si está configurado, también debe configurar `key-file` y `cert-file`. |
| `listen-unix` | `NTFY_LISTEN_UNIX` | *Nombre* | - | Ruta a un socket Unix para escuchar en |
| `key-file` | `NTFY_KEY_FILE` | *Nombre* | - | Archivo de clave privada HTTPS/TLS, solo se usa si `listen-https` está configurado. |
| `cert-file` | `NTFY_CERT_FILE` | *Nombre* | - | Archivo de certificado HTTPS/TLS, solo se usa si `listen-https` está configurado. |
| `firebase-key-file` | `NTFY_FIREBASE_KEY_FILE` | *Nombre* | - | Si está configurado, publica también mensajes en un tema de Firebase Cloud Messaging (FCM) para tu aplicación. Esto es opcional y solo es necesario para ahorrar batería cuando se usa la aplicación de Android. Ver [Base de fuego (FCM)](#firebase-fcm). |
| `cache-file` | `NTFY_CACHE_FILE` | *Nombre* | - | Si se establece, los mensajes se almacenan en caché en una base de datos SQLite local en lugar de solo en memoria. Esto permite reiniciar el servicio sin perder mensajes en apoyo del parámetro since=. Ver [caché de mensajes](#message-cache). |
| `cache-duration` | `NTFY_CACHE_DURATION` | *duración* | 12h | Duración durante la cual los mensajes se almacenarán en búfer antes de que se eliminen. Esto es necesario para apoyar el `since=...` y `poll=1` parámetro. Establezca esto en `0` para deshabilitar la memoria caché por completo. |
| `cache-startup-queries` | `NTFY_CACHE_STARTUP_QUERIES` | *cadena (consultas SQL)* | - | Consultas SQL para ejecutar durante el inicio de la base de datos; Esto es útil para ajustar y [habilitar el modo WAL](#wal-for-message-cache) |
| `auth-file` | `NTFY_AUTH_FILE` | *Nombre* | - | Archivo de base de datos de autenticación utilizado para el control de acceso. Si se establece, habilita la autenticación y el control de acceso. Ver [control de acceso](#access-control). |
| `auth-default-access` | `NTFY_AUTH_DEFAULT_ACCESS` | `read-write`, `read-only`, `write-only`, `deny-all` | `read-write` | Permisos predeterminados si no se encuentran entradas coincidentes en la base de datos de autenticación. El valor predeterminado es `read-write`. |
| `behind-proxy` | `NTFY_BEHIND_PROXY` | *Bool* | | falso Si se establece, el encabezado X-Forwarded-For se utiliza para determinar la dirección IP del visitante en lugar de la dirección remota de la conexión. |
| `attachment-cache-dir` | `NTFY_ATTACHMENT_CACHE_DIR` | *directorio* | - | Directorio de caché para archivos adjuntos. Para habilitar los archivos adjuntos, esto debe establecerse. |
| `attachment-total-size-limit` | `NTFY_ATTACHMENT_TOTAL_SIZE_LIMIT` | *tamaño* | | 5G Límite del directorio de caché de datos adjuntos en disco. Si se superan los límites, se rechazarán los nuevos archivos adjuntos. |
| `attachment-file-size-limit` | `NTFY_ATTACHMENT_FILE_SIZE_LIMIT` | *tamaño* | 15M | Límite de tamaño de archivos adjuntos por archivo (por ejemplo, 300k, 2M, 100M). Se rechazará el archivo adjunto más grande. |
| `attachment-expiry-duration` | `NTFY_ATTACHMENT_EXPIRY_DURATION` | *duración* | 3h | Duración después de la cual se eliminarán los archivos adjuntos cargados (por ejemplo, 3h, 20h). Afecta fuertemente `visitor-attachment-total-size-limit`. |
| `smtp-sender-addr` | `NTFY_SMTP_SENDER_ADDR` | `host:port` | - | Dirección del servidor SMTP para permitir el envío de correo electrónico |
| `smtp-sender-user` | `NTFY_SMTP_SENDER_USER` | *cuerda* | - | Usuario SMTP; sólo se utiliza si el envío de correo electrónico está habilitado |
| `smtp-sender-pass` | `NTFY_SMTP_SENDER_PASS` | *cuerda* | - | Contraseña SMTP; sólo se utiliza si el envío de correo electrónico está habilitado |
| `smtp-sender-from` | `NTFY_SMTP_SENDER_FROM` | *dirección de correo electrónico* | - | Dirección de correo electrónico del remitente SMTP; sólo se utiliza si el envío de correo electrónico está habilitado |
| `smtp-server-listen` | `NTFY_SMTP_SERVER_LISTEN` | `[ip]:port` | - | Define la dirección IP y el puerto en el que escuchará el servidor SMTP, por ejemplo. `:25` o `1.2.3.4:25` |
| `smtp-server-domain` | `NTFY_SMTP_SERVER_DOMAIN` | *nombre de dominio* | - | Dominio de correo electrónico del servidor SMTP, por ejemplo. `ntfy.sh` |
| `smtp-server-addr-prefix` | `NTFY_SMTP_SERVER_ADDR_PREFIX` | `[ip]:port` | - | Prefijo opcional para las direcciones de correo electrónico para evitar el spam, por ejemplo. `ntfy-` |
| `keepalive-interval` | `NTFY_KEEPALIVE_INTERVAL` | *duración* | 45s | Intervalo en el que se envían mensajes keepalive al cliente. Esto es para evitar que los intermediarios cierren la conexión por inactividad. Tenga en cuenta que la aplicación de Android tiene un tiempo de espera codificado en 77s, por lo que debería ser menor que eso. |
| `manager-interval` | `$NTFY_MANAGER_INTERVAL` | *duración* | 1m de | Intervalo en el que el administrador poda los mensajes antiguos, elimina los temas e imprime las estadísticas. |
| `global-topic-limit` | `NTFY_GLOBAL_TOPIC_LIMIT` | *número* | 15.000 | Limitación de velocidad: número total de temas antes de que el servidor rechace nuevos temas. |
| `upstream-base-url` | `NTFY_UPSTREAM_BASE_URL` | *URL* | `https://ntfy.sh` | Reenviar la solicitud de sondeo a un servidor ascendente, esto es necesario para las notificaciones push de iOS para servidores autohospedados |
| `visitor-attachment-total-size-limit` | `NTFY_VISITOR_ATTACHMENT_TOTAL_SIZE_LIMIT` | *tamaño* | 100M | Limitación de velocidad: Límite de almacenamiento total utilizado para archivos adjuntos por visitante, para todos los archivos adjuntos combinados. El almacenamiento se libera después de que expiran los archivos adjuntos. Ver `attachment-expiry-duration`. |
| `visitor-attachment-daily-bandwidth-limit` | `NTFY_VISITOR_ATTACHMENT_DAILY_BANDWIDTH_LIMIT` | *tamaño* | 500M | Limitación de velocidad: Límite total de tráfico diario de descarga/carga de archivos adjuntos por visitante. Esto es para proteger sus costos de ancho de banda de la explosión. |
| `visitor-email-limit-burst` | `NTFY_VISITOR_EMAIL_LIMIT_BURST` | *número* | 16 | Limitación de velocidad: Límite inicial de correos electrónicos por visitante |
| `visitor-email-limit-replenish` | `NTFY_VISITOR_EMAIL_LIMIT_REPLENISH` | *duración* | 1h | Limitación de velocidad: Fuertemente relacionado con `visitor-email-limit-burst`: La velocidad a la que se rellena el cubo |
| `visitor-request-limit-burst` | `NTFY_VISITOR_REQUEST_LIMIT_BURST` | *número* | 60 | Limitación de velocidad: Solicitudes GET/PUT/POST permitidas por segundo, por visitante. Esta configuración es el grupo inicial de solicitudes que cada visitante ha |
| `visitor-request-limit-replenish` | `NTFY_VISITOR_REQUEST_LIMIT_REPLENISH` | *duración* | 5s | Limitación de velocidad: Fuertemente relacionado con `visitor-request-limit-burst`: La velocidad a la que se rellena el cubo |
| `visitor-request-limit-exempt-hosts` | `NTFY_VISITOR_REQUEST_LIMIT_EXEMPT_HOSTS` | *lista de hosts/IP separados por comas* | - | Limitación de velocidad: Lista de nombres de host e IP que estarán exentos de la limitación de velocidad de solicitud |
| `visitor-subscription-limit` | `NTFY_VISITOR_SUBSCRIPTION_LIMIT` | *número* | 30 | Limitación de velocidad: Número de suscripciones por visitante (dirección IP) |
| `web-root` | `NTFY_WEB_ROOT` | `app`, `home` o `disable` | `app` | Establece la raíz web en la página de destino (inicio), la aplicación web (aplicación) o deshabilita la aplicación web por completo (deshabilitar) |
El formato de un *duración* es: `<number>(smh)`, por ejemplo, 30s, 20m o 1h.\
El formato de un *tamaño* es: `<number>(GMK)`, por ejemplo, 1G, 200M o 4000k.
## Opciones de línea de comandos
$ ntfy serve --help
NAME:
ntfy serve - Run the ntfy server
USAGE:
ntfy serve [OPTIONS..]
CATEGORY:
Server commands
DESCRIPTION:
Run the ntfy server and listen for incoming requests
The command will load the configuration from /etc/ntfy/server.yml. Config options can
be overridden using the command line options.
Examples:
ntfy serve # Starts server in the foreground (on port 80)
ntfy serve --listen-http :8080 # Starts server with alternate port
OPTIONS:
--attachment-cache-dir value, --attachment_cache_dir value cache directory for attached files [$NTFY_ATTACHMENT_CACHE_DIR]
--attachment-expiry-duration value, --attachment_expiry_duration value, -X value duration after which uploaded attachments will be deleted (e.g. 3h, 20h) (default: 3h) [$NTFY_ATTACHMENT_EXPIRY_DURATION]
--attachment-file-size-limit value, --attachment_file_size_limit value, -Y value per-file attachment size limit (e.g. 300k, 2M, 100M) (default: 15M) [$NTFY_ATTACHMENT_FILE_SIZE_LIMIT]
--attachment-total-size-limit value, --attachment_total_size_limit value, -A value limit of the on-disk attachment cache (default: 5G) [$NTFY_ATTACHMENT_TOTAL_SIZE_LIMIT]
--auth-default-access value, --auth_default_access value, -p value default permissions if no matching entries in the auth database are found (default: "read-write") [$NTFY_AUTH_DEFAULT_ACCESS]
--auth-file value, --auth_file value, -H value auth database file used for access control [$NTFY_AUTH_FILE]
--base-url value, --base_url value, -B value externally visible base URL for this host (e.g. https://ntfy.sh) [$NTFY_BASE_URL]
--behind-proxy, --behind_proxy, -P if set, use X-Forwarded-For header to determine visitor IP address (for rate limiting) (default: false) [$NTFY_BEHIND_PROXY]
--cache-duration since, --cache_duration since, -b since buffer messages for this time to allow since requests (default: 12h0m0s) [$NTFY_CACHE_DURATION]
--cache-file value, --cache_file value, -C value cache file used for message caching [$NTFY_CACHE_FILE]
--cache-startup-queries value, --cache_startup_queries value queries run when the cache database is initialized [$NTFY_CACHE_STARTUP_QUERIES]
--cert-file value, --cert_file value, -E value certificate file, if listen-https is set [$NTFY_CERT_FILE]
--config value, -c value config file (default: /etc/ntfy/server.yml) [$NTFY_CONFIG_FILE]
--debug, -d enable debug logging (default: false) [$NTFY_DEBUG]
--firebase-key-file value, --firebase_key_file value, -F value Firebase credentials file; if set additionally publish to FCM topic [$NTFY_FIREBASE_KEY_FILE]
--global-topic-limit value, --global_topic_limit value, -T value total number of topics allowed (default: 15000) [$NTFY_GLOBAL_TOPIC_LIMIT]
--keepalive-interval value, --keepalive_interval value, -k value interval of keepalive messages (default: 45s) [$NTFY_KEEPALIVE_INTERVAL]
--key-file value, --key_file value, -K value private key file, if listen-https is set [$NTFY_KEY_FILE]
--listen-http value, --listen_http value, -l value ip:port used to as HTTP listen address (default: ":80") [$NTFY_LISTEN_HTTP]
--listen-https value, --listen_https value, -L value ip:port used to as HTTPS listen address [$NTFY_LISTEN_HTTPS]
--listen-unix value, --listen_unix value, -U value listen on unix socket path [$NTFY_LISTEN_UNIX]
--log-level value, --log_level value set log level (default: "INFO") [$NTFY_LOG_LEVEL]
--manager-interval value, --manager_interval value, -m value interval of for message pruning and stats printing (default: 1m0s) [$NTFY_MANAGER_INTERVAL]
--no-log-dates, --no_log_dates disable the date/time prefix (default: false) [$NTFY_NO_LOG_DATES]
--smtp-sender-addr value, --smtp_sender_addr value SMTP server address (host:port) for outgoing emails [$NTFY_SMTP_SENDER_ADDR]
--smtp-sender-from value, --smtp_sender_from value SMTP sender address (if e-mail sending is enabled) [$NTFY_SMTP_SENDER_FROM]
--smtp-sender-pass value, --smtp_sender_pass value SMTP password (if e-mail sending is enabled) [$NTFY_SMTP_SENDER_PASS]
--smtp-sender-user value, --smtp_sender_user value SMTP user (if e-mail sending is enabled) [$NTFY_SMTP_SENDER_USER]
--smtp-server-addr-prefix value, --smtp_server_addr_prefix value SMTP email address prefix for topics to prevent spam (e.g. 'ntfy-') [$NTFY_SMTP_SERVER_ADDR_PREFIX]
--smtp-server-domain value, --smtp_server_domain value SMTP domain for incoming e-mail, e.g. ntfy.sh [$NTFY_SMTP_SERVER_DOMAIN]
--smtp-server-listen value, --smtp_server_listen value SMTP server address (ip:port) for incoming emails, e.g. :25 [$NTFY_SMTP_SERVER_LISTEN]
--trace enable tracing (very verbose, be careful) (default: false) [$NTFY_TRACE]
--upstream-base-url value, --upstream_base_url value forward poll request to an upstream server, this is needed for iOS push notifications for self-hosted servers [$NTFY_UPSTREAM_BASE_URL]
--visitor-attachment-daily-bandwidth-limit value, --visitor_attachment_daily_bandwidth_limit value total daily attachment download/upload bandwidth limit per visitor (default: "500M") [$NTFY_VISITOR_ATTACHMENT_DAILY_BANDWIDTH_LIMIT]
--visitor-attachment-total-size-limit value, --visitor_attachment_total_size_limit value total storage limit used for attachments per visitor (default: "100M") [$NTFY_VISITOR_ATTACHMENT_TOTAL_SIZE_LIMIT]
--visitor-email-limit-burst value, --visitor_email_limit_burst value initial limit of e-mails per visitor (default: 16) [$NTFY_VISITOR_EMAIL_LIMIT_BURST]
--visitor-email-limit-replenish value, --visitor_email_limit_replenish value interval at which burst limit is replenished (one per x) (default: 1h0m0s) [$NTFY_VISITOR_EMAIL_LIMIT_REPLENISH]
--visitor-request-limit-burst value, --visitor_request_limit_burst value initial limit of requests per visitor (default: 60) [$NTFY_VISITOR_REQUEST_LIMIT_BURST]
--visitor-request-limit-exempt-hosts value, --visitor_request_limit_exempt_hosts value hostnames and/or IP addresses of hosts that will be exempt from the visitor request limit [$NTFY_VISITOR_REQUEST_LIMIT_EXEMPT_HOSTS]
--visitor-request-limit-replenish value, --visitor_request_limit_replenish value interval at which burst limit is replenished (one per x) (default: 5s) [$NTFY_VISITOR_REQUEST_LIMIT_REPLENISH]
--visitor-subscription-limit value, --visitor_subscription_limit value number of subscriptions per visitor (default: 30) [$NTFY_VISITOR_SUBSCRIPTION_LIMIT]
--web-root value, --web_root value sets web root to landing page (home), web app (app) or disabled (disable) (default: "app") [$NTFY_WEB_ROOT]

59
docs/deprecations-es.md Normal file
View file

@ -0,0 +1,59 @@
# Avisos de obsolescencia
Esta página se utiliza para enumerar los avisos de obsolescencia para ntfy. Los comandos y opciones obsoletos serán
**eliminado después de 1-3 meses** desde el momento en que quedaron en desuso. Cuánto tiempo la función está en desuso
antes de que se cambie el comportamiento depende de la gravedad del cambio y de lo prominente que sea la característica.
## Obsolescencias activas
### CLI ntfy: `ntfy publish --env-topic` se eliminará
> Activo desde 2022-06-20, el comportamiento cambiará al final de **Julio 2022**
El `ntfy publish --env-topic` se eliminará la opción. Todavía será posible especificar un tema a través del
`NTFY_TOPIC` variable de entorno, pero ya no será necesario especificar el `--env-topic` bandera.
\=== "Antes"
` $ NTFY_TOPIC=mytopic ntfy publish --env-topic "this is the message"
`
\=== "Después"
` $ NTFY_TOPIC=mytopic ntfy publish "this is the message"
`
## Obsolescencias anteriores
### <del>Aplicación Android: WebSockets se convertirá en el protocolo de conexión predeterminado</del>
> Activo desde 2022-03-13, el comportamiento no cambiará (desuso eliminado 2022-06-20)
Las conexiones de entrega instantánea y las conexiones a servidores autohospedados en la aplicación de Android iban a cambiar
para utilizar el protocolo WebSockets de forma predeterminada. Se decidió mantener json stream como el valor predeterminado más compatible
y agregue un banner de aviso en la aplicación de Android en su lugar.
### Aplicación Android: Uso `since=<timestamp>` En lugar de `since=<id>`
> Activo desde 2022-02-27, el comportamiento cambió con v1.14.0
La aplicación de Android comenzó a usar `since=<id>` En lugar de `since=<timestamp>`, lo que significa a partir de la aplicación de Android v1.14.0,
ya no funcionará con servidores anteriores a v1.16.0. Esto es para simplificar el manejo de la deduplicación en la aplicación de Android.
El `since=<timestamp>` endpoint seguirá funcionando. Esto es simplemente un aviso de que el comportamiento de la aplicación de Android cambiará.
### Ejecución del servidor a través de `ntfy` (en lugar de `ntfy serve`)
> Obsoleto 2021-12-17, el comportamiento cambió con v1.10.0
A medida que se agregan más comandos al `ntfy` Herramienta CLI, usando solo `ntfy` Ejecutar el servidor no es práctico
ya. Por favor, utilice `ntfy serve` en lugar de. Esto también se aplica a las imágenes de Docker, ya que también pueden ejecutar más de
solo el servidor.
\=== "Antes"
` $ ntfy
2021/12/17 08:16:01 Listening on :80/http
`
\=== "Después"
` $ ntfy serve
2021/12/17 08:16:01 Listening on :80/http
`

343
docs/develop-es.md Normal file
View file

@ -0,0 +1,343 @@
# Desarrollo
¡Hurra 🥳 🎉, estás interesado en escribir código para ntfy! **Eso es increíble.** 😎
Hice todo lo posible para escribir instrucciones detalladas, pero si en algún momento te encuentras con problemas, no lo hagas.
dudar en **contáctame en [Discordia](https://discord.gg/cT7ECsZj9w) o [Matriz](https://matrix.to/#/#ntfy:matrix.org)**.
## Servidor ntfy
El código fuente del servidor ntfy está disponible [en GitHub](https://github.com/binwiederhier/ntfy). La base de código para el
el servidor consta de tres componentes:
* **El servidor/cliente principal** está escrito en [Ir](https://go.dev/) (así que necesitarás Go). Su punto de entrada principal está en
[main.go](https://github.com/binwiederhier/ntfy/blob/main/main.go), y la carne que probablemente te interese es
en [servidor.go](https://github.com/binwiederhier/ntfy/blob/main/server/server.go). En particular, el servidor utiliza un
[SQLite](https://sqlite.org) biblioteca llamada [go-sqlite3](https://github.com/mattn/go-sqlite3), que requiere
[Cgo](https://go.dev/blog/cgo) y `CGO_ENABLED=1` para ser establecido. De lo contrario, las cosas no funcionarán (ver más abajo).
* **La documentación** es generado por [MkDocs](https://www.mkdocs.org/) y [Material para MkDocs](https://squidfunk.github.io/mkdocs-material/),
que está escrito en [Pitón](https://www.python.org/). Necesitarás Python y MkDocs (a través de `pip`) sólo si desea
compila los documentos.
* **La aplicación web** está escrito en [Reaccionar](https://reactjs.org/)Usando [MUI](https://mui.com/). Utiliza [Crear la aplicación React](https://create-react-app.dev/)
para construir la compilación de producción. Si desea modificar la aplicación web, necesita [nodejs](https://nodejs.org/en/) (para `npm`)
e instalar todas las 100.000 dependencias (*suspirar*).
Todos estos componentes se construyen y luego **horneado en un binario**.
### Navegación por el código
Código:
* [main.go](https://github.com/binwiederhier/ntfy/blob/main/main.go) - Punto de entrada principal en la CLI, tanto para el servidor como para el cliente
* [cmd/](https://github.com/binwiederhier/ntfy/tree/main/cmd) - Comandos de la CLI, como `serve` o `publish`
* [servidor/](https://github.com/binwiederhier/ntfy/tree/main/server) - La carne de la lógica del servidor
* [documentos/](https://github.com/binwiederhier/ntfy/tree/main/docs) - El [MkDocs](https://www.mkdocs.org/) documentación, consulte también `mkdocs.yml`
* [web/](https://github.com/binwiederhier/ntfy/tree/main/web) - El [Reaccionar](https://reactjs.org/) aplicación, ver también `web/package.json`
Construcción relacionada:
* [Makefile](https://github.com/binwiederhier/ntfy/blob/main/Makefile) - Punto de entrada principal para todo lo relacionado con la construcción
* [.goreleaser.yml](https://github.com/binwiederhier/ntfy/blob/main/.goreleaser.yml) - Describe todos los resultados de compilación (para [GoReleaser](https://goreleaser.com/))
* [go.mod](https://github.com/binwiederhier/ntfy/blob/main/go.mod) - Archivo de dependencia de módulos Go
* [mkdocs.yml](https://github.com/binwiederhier/ntfy/blob/main/mkdocs.yml) - Archivo de configuración para los documentos (para [MkDocs](https://www.mkdocs.org/))
* [web/paquete.json](https://github.com/binwiederhier/ntfy/blob/main/web/package.json) - Compilación y archivo de dependencia para la aplicación web (para npm)
El `web/` y `docs/` son los orígenes de la aplicación web y la documentación. Durante el proceso de construcción,
El resultado generado se copia en `server/site` (aplicación web y página de destino) y `server/docs` (documentación).
### Requisitos de compilación
* [Ir](https://go.dev/) (requerido para el servidor principal)
* [Gcc](https://gcc.gnu.org/) (servidor principal requerido, para enlaces basados en SQLite cgo)
* [Hacer](https://www.gnu.org/software/make/) (requerido por conveniencia)
* [libsqlite3/libsqlite3-dev](https://www.sqlite.org/) (requerido para el servidor principal, para enlaces basados en SQLite cgo)
* [GoReleaser](https://goreleaser.com/) (requerido para una compilación adecuada del servidor principal)
* [Pitón](https://www.python.org/) (para `pip`, sólo para compilar los documentos)
* [nodejs](https://nodejs.org/en/) (para `npm`, solo para compilar la aplicación web)
### Instalar dependencias
Estos pasos **asumir Ubuntu**. Los pasos pueden variar en diferentes distribuciones de Linux.
Primero, instale [Ir](https://go.dev/) (ver [instrucciones oficiales](https://go.dev/doc/install)):
```shell
wget https://go.dev/dl/go1.18.linux-amd64.tar.gz
rm -rf /usr/local/go && tar -C /usr/local -xzf go1.18.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin
go version # verifies that it worked
```
Instalar [GoReleaser](https://goreleaser.com/) (ver [instrucciones oficiales](https://goreleaser.com/install/)):
```shell
go install github.com/goreleaser/goreleaser@latest
goreleaser -v # verifies that it worked
```
Instalar [nodejs](https://nodejs.org/en/) (ver [instrucciones oficiales](https://nodejs.org/en/download/package-manager/)):
```shell
curl -fsSL https://deb.nodesource.com/setup_17.x | sudo -E bash -
sudo apt-get install -y nodejs
npm -v # verifies that it worked
```
A continuación, instale algunas otras cosas necesarias:
```shell
sudo apt install \
build-essential \
libsqlite3-dev \
gcc-arm-linux-gnueabi \
gcc-aarch64-linux-gnu \
python3-pip \
upx \
git
```
### Comprobar código
Ahora echa un vistazo a través de git desde el [Repositorio de GitHub](https://github.com/binwiederhier/ntfy):
\=== "vía HTTPS"
` shell
git clone https://github.com/binwiederhier/ntfy.git
cd ntfy
`
\=== "vía SSH"
` shell
git clone git@github.com:binwiederhier/ntfy.git
cd ntfy
`
### Construye todas las cosas
Ahora finalmente puedes construir todo. Hay toneladas de `make` objetivos, así que tal vez solo revise lo que hay primero
escribiendo `make`:
```shell
$ make
Typical commands (more see below):
make build - Build web app, documentation and server/client (sloowwww)
make cli-linux-amd64 - Build server/client binary (amd64, no web app or docs)
make install-linux-amd64 - Install ntfy binary to /usr/bin/ntfy (amd64)
make web - Build the web app
make docs - Build the documentation
make check - Run all tests, vetting/formatting checks and linters
...
```
Si quieres construir el **Ntfy binario, incluida la aplicación web y los documentos para todas las arquitecturas compatibles** (amd64, armv7 y arm64),
simplemente puede ejecutar `make build`:
```shell
$ make build
...
# This builds web app, docs, and the ntfy binary (for amd64, armv7 and arm64).
# This will be SLOW (5+ minutes on my laptop on the first run). Maybe look at the other make targets?
```
Verás todas las salidas en el `dist/` carpeta después:
```bash
$ find dist
dist
dist/metadata.json
dist/ntfy_arm64_linux_arm64
dist/ntfy_arm64_linux_arm64/ntfy
dist/ntfy_armv7_linux_arm_7
dist/ntfy_armv7_linux_arm_7/ntfy
dist/ntfy_amd64_linux_amd64
dist/ntfy_amd64_linux_amd64/ntfy
dist/config.yaml
dist/artifacts.json
```
Si también desea construir el **Paquetes Debian/RPM e imágenes de Docker para todas las arquitecturas soportadas**Puedes
utilice el botón `make release-snapshot` blanco:
```shell
$ make release-snapshot
...
# This will be REALLY SLOW (sometimes 5+ minutes on my laptop)
```
Durante el desarrollo, es posible que desee ser más exigente y construir solo ciertas cosas. Aquí hay algunos ejemplos.
### Construir el binario ntfy
Para construir sólo el `ntfy` binario **sin la aplicación web o la documentación**, utilice el botón `make cli-...` Objetivos:
```shell
$ make
Build server & client (using GoReleaser, not release version):
make cli - Build server & client (all architectures)
make cli-linux-amd64 - Build server & client (Linux, amd64 only)
make cli-linux-armv6 - Build server & client (Linux, armv6 only)
make cli-linux-armv7 - Build server & client (Linux, armv7 only)
make cli-linux-arm64 - Build server & client (Linux, arm64 only)
make cli-windows-amd64 - Build client (Windows, amd64 only)
make cli-darwin-all - Build client (macOS, arm64+amd64 universal binary)
```
Entonces, si está en una máquina basada en amd64 / x86\_64, es posible que solo desee ejecutar `make cli-linux-amd64` durante las pruebas. En un moderno
sistema, esto no debería tomar más de 5-10 segundos. A menudo lo combino con `install-linux-amd64` para que pueda ejecutar el binario
Ahora mismo:
```shell
$ make cli-linux-amd64 install-linux-amd64
$ ntfy serve
```
**Durante el desarrollo de la aplicación principal, también puede usar `go run main.go`**, siempre y cuando corras
`make cli-deps-static-sites`al menos una vez y `CGO_ENABLED=1`:
```shell
$ export CGO_ENABLED=1
$ make cli-deps-static-sites
$ go run main.go serve
2022/03/18 08:43:55 Listening on :2586[http]
...
```
Si no corres `cli-deps-static-sites`, es posible que vea un error *`pattern ...: no matching files found`*:
$ go run main.go serve
server/server.go:85:13: pattern docs: no matching files found
Esto se debe a que usamos `go:embed` para incrustar la documentación y la aplicación web, por lo que el código Go espera que los archivos sean
presente en `server/docs` y `server/site`. Si no lo son, verá el error anterior. El `cli-deps-static-sites`
target crea archivos ficticios que garantizan que podrá compilar.
Aunque no es oficialmente compatible (o lanzado), puede compilar y ejecutar el servidor **en macOS** También. Simplemente ejecute
`make cli-darwin-server` para crear un binario, o `go run main.go serve` (ver arriba) para ejecutarlo.
### Compilar la aplicación web
Los orígenes de la aplicación web viven en `web/`. Siempre y cuando tengas `npm` instalado (consulte más arriba), creación de la aplicación web
es realmente simple. Simplemente escriba `make web` y estás en el negocio:
```shell
$ make web
...
```
Esto creará la aplicación web mediante Crear aplicación React y luego **Copie la compilación de producción en el cuadro `server/site` carpeta**así que
que cuando `make cli` (o `make cli-linux-amd64`, ...), tendrás la web app incluida en el `ntfy` binario.
Si está desarrollando en la aplicación web, es mejor simplemente `cd web` y ejecutar `npm start` manualmente. Esto abrirá su navegador
en `http://127.0.0.1:3000` con la aplicación web, y a medida que edite los archivos de origen, se volverán a compilar y el explorador
se actualizará automáticamente:
```shell
$ cd web
$ npm start
```
### Crear los documentos
Las fuentes de los documentos viven en `docs/`. De manera similar a la aplicación web, simplemente puede ejecutar `make docs` para crear el
documentación. Siempre y cuando tengas `mkdocs` instalado (ver arriba), esto debería funcionar bien:
```shell
$ make docs
...
```
Si va a cambiar la documentación, debería estar ejecutando `mkdocs serve` directamente. Esto construirá la documentación,
Servir los archivos en `http://127.0.0.1:8000/`y vuelva a generar cada vez que guarde los archivos de origen:
$ mkdocs serve
INFO - Building documentation...
INFO - Cleaning site directory
INFO - Documentation built in 5.53 seconds
INFO - [16:28:14] Serving on http://127.0.0.1:8000/
Luego puede navegar a http://127.0.0.1:8000/ y cada vez que cambie un archivo de marcado en su editor de texto, se actualizará automáticamente.
## Aplicación para Android
El código fuente de la aplicación ntfy para Android está disponible [en GitHub](https://github.com/binwiederhier/ntfy-android).
La aplicación de Android tiene dos sabores:
* **Google Play:** El `play` sabor incluye [Base de fuego (FCM)](https://firebase.google.com/) y requiere una cuenta de Firebase
* **F-Droide:** El `fdroid` Flavor no incluye dependencias de Firebase o Google
### Navegación por el código
* [principal/](https://github.com/binwiederhier/ntfy-android/tree/main/app/src/main) - Código fuente principal de la aplicación Android
* [jugar/](https://github.com/binwiederhier/ntfy-android/tree/main/app/src/play) - Código específico de Google Play / Firebase
* [fdroid/](https://github.com/binwiederhier/ntfy-android/tree/main/app/src/fdroid) - Talones de F-Droid Firebase
* [build.gradle](https://github.com/binwiederhier/ntfy-android/blob/main/app/build.gradle) - Archivo de compilación principal
### IDE/Medio ambiente
Deberías descargar [Estudio Android](https://developer.android.com/studio) (o [IntelliJ IDEA](https://www.jetbrains.com/idea/)
con los plugins de Android pertinentes). Todo lo demás será un dolor para ti. Hazte un favor. 😀
### Echa un vistazo al código
Primero echa un vistazo al repositorio:
\=== "vía HTTPS"
` shell
git clone https://github.com/binwiederhier/ntfy-android.git
cd ntfy-android
`
\=== "vía SSH"
` shell
git clone git@github.com:binwiederhier/ntfy-android.git
cd ntfy-android
`
A continuación, sigue los pasos para construir con o sin Firebase.
### Construir sabor F-Droid (sin FCM)
!!! información
Construyo la aplicación ntfy para Android usando IntelliJ IDEA (Android Studio), así que no sé si estos comandos de Gradle lo harán.
trabajar sin problemas. Por favor, dame tu opinión si funciona o no funciona para ti.
Sin Firebase, es posible que desees seguir cambiando el valor predeterminado `app_base_url` en [valores.xml](https://github.com/binwiederhier/ntfy-android/blob/main/app/src/main/res/values/values.xml)
si está autohospedando el servidor. Luego corre:
# Remove Google dependencies (FCM)
sed -i -e '/google-services/d' build.gradle
sed -i -e '/google-services/d' app/build.gradle
# To build an unsigned .apk (app/build/outputs/apk/fdroid/*.apk)
./gradlew assembleFdroidRelease
# To build a bundle .aab (app/fdroid/release/*.aab)
./gradlew bundleFdroidRelease
### Sabor Build Play (FCM)
!!! información
Construyo la aplicación ntfy para Android usando IntelliJ IDEA (Android Studio), así que no sé si estos comandos de Gradle lo harán.
trabajar sin problemas. Por favor, dame tu opinión si funciona o no funciona para ti.
Para crear tu propia versión con Firebase, debes:
* Crear una cuenta de Firebase/FCM
* Coloque el archivo de su cuenta en `app/google-services.json`
* Y cambio `app_base_url` en [valores.xml](https://github.com/binwiederhier/ntfy-android/blob/main/app/src/main/res/values/values.xml)
* Luego corre:
<!---->
# To build an unsigned .apk (app/build/outputs/apk/play/*.apk)
./gradlew assemblePlayRelease
# To build a bundle .aab (app/play/release/*.aab)
./gradlew bundlePlayRelease
## Aplicación iOS
El código fuente de la aplicación ntfy iOS está disponible [en GitHub](https://github.com/binwiederhier/ntfy-ios).
!!! información
No he tenido tiempo de mover las instrucciones de compilación aquí. Por favor, echa un vistazo al repositorio en su lugar.

1831
docs/emojis-es.md Normal file
View file

File diff suppressed because it is too large Load diff

467
docs/examples-es.md Normal file
View file

@ -0,0 +1,467 @@
# Ejemplos
Hay un millón de formas de usar ntfy, pero aquí hay algunas inspiraciones. Trato de coleccionar <a href="https://github.com/binwiederhier/ntfy/tree/main/examples">ejemplos en GitHub</a>, así que asegúrese de comprobar
los que están fuera, también.
!!! información
Muchos de estos ejemplos fueron aportados por usuarios de ntfy. Si tiene otros ejemplos de cómo usa ntfy, por favor
[Crear una solicitud de extracción](https://github.com/binwiederhier/ntfy/pulls), y felizmente lo incluiré. También tenga en cuenta que
No puedo garantizar que todos estos ejemplos sean funcionales. Muchos de ellos no los he probado yo mismo.
## Cronjobs
ntfy es perfecto para cualquier tipo de cronjobs o justo cuando se realizan procesos largos (copias de seguridad, pipelines, comandos de copia rsync, ...).
Comencé a agregar notificaciones en casi todos mis scripts. Por lo general, solo encadeno el <tt>rizo</tt> llamar
directamente al comando que estoy ejecutando. El siguiente ejemplo enviará <i>La copia de seguridad de la computadora portátil se realizó correctamente</i>
o ⚠️ <i>Error en la copia de seguridad de la computadora portátil</i> directamente a mi teléfono:
rsync -a root@laptop /backups/laptop \
&& zfs snapshot ... \
&& curl -H prio:low -d "Laptop backup succeeded" ntfy.sh/backups \
|| curl -H tags:warning -H prio:high -d "Laptop backup failed" ntfy.sh/backups
Aquí hay uno para los libros de historia. Quiero desesperadamente el `github.com/ntfy` organización, pero todas mis entradas con
GitHub ha estado desesperado. En caso de que alguna vez esté disponible, quiero saberlo de inmediato.
```cron
# Check github/ntfy user
*/6 * * * * if curl -s https://api.github.com/users/ntfy | grep "Not Found"; then curl -d "github.com/ntfy is available" -H "Tags: tada" -H "Prio: high" ntfy.sh/my-alerts; fi
```
## Alertas de poco espacio en disco
Aquí hay un cronjob simple que uso para avisarme cuando el espacio en disco en el disco raíz se está agotando. Es simple, pero
eficaz.
```bash
#!/bin/bash
mingigs=10
avail=$(df | awk '$6 == "/" && $4 < '$mingigs' * 1024*1024 { print $4/1024/1024 }')
topicurl=https://ntfy.sh/mytopic
if [ -n "$avail" ]; then
curl \
-d "Only $avail GB available on the root disk. Better clean that up." \
-H "Title: Low disk space alert on $(hostname)" \
-H "Priority: high" \
-H "Tags: warning,cd" \
$topicurl
fi
```
## Alertas de inicio de sesión SSH
Hace años mi servidor doméstico fue allanado. Eso me sacudió con fuerza, así que cada vez que alguien inicia sesión en cualquier máquina que yo
Propio, ahora me envío un mensaje. Aquí hay un ejemplo de cómo usar <a href="https://en.wikipedia.org/wiki/Linux_PAM">PAM</a>
para notificarse a sí mismo en el inicio de sesión SSH.
\=== "/etc/pam.d/sshd"
` # at the end of the file
session optional pam_exec.so /usr/bin/ntfy-ssh-login.sh
`
\=== "/usr/bin/ntfy-ssh-login.sh"
` bash #!/bin/bash
if [ "${PAM_TYPE}" = "open_session" ]; then
curl \ -H prio:high \ -H tags:warning \ -d "SSH login: ${PAM_USER} from ${PAM_RHOST}" \
ntfy.sh/alerts
fi
`
## Recopilar datos de varias máquinas
El otro día estaba ejecutando tareas en 20 servidores, y quería recopilar los resultados provisionales.
como csv en un solo lugar. Cada uno de los servidores se publicaba en un tema a medida que se completaban los resultados (`publish-result.sh`),
y tenía un colector central para obtener los resultados a medida que entraban (`collect-results.sh`).
Se veía algo como esto:
\=== "collect-results.sh"
` bash
while read result; do [ -n "$result" ] && echo "$result" >> results.csv
done < <(stdbuf -i0 -o0 curl -s ntfy.sh/results/raw)
`
\=== "publish-result.sh"
'''bash
Este script se ejecutó en cada uno de los 20 servidores. Estaba haciendo un procesamiento pesado ...
// Publish script results
curl -d "$(hostname),$count,$time" ntfy.sh/results
```
## Ansible, Sal y Títere
Puede integrar fácilmente ntfy en Ansible, Salt o Puppet para notificarle cuando se realizan o se realizan carreras.
Uno de mis compañeros de trabajo utiliza la siguiente tarea de Ansible para hacerle saber cuándo se hacen las cosas:
```yml
- name: Send ntfy.sh update
uri:
url: "https://ntfy.sh/{{ ntfy_channel }}"
method: POST
body: "{{ inventory_hostname }} reseeding complete"
```
## Atalaya (shoutrrr)
Puedes usar [gritarrr](https://github.com/containrrr/shoutrrr) Soporte genérico de webhook para enviar
[Atalaya](https://github.com/containrrr/watchtower/) notificaciones a su tema ntfy.
Ejemplo docker-compose.yml:
```yml
services:
watchtower:
image: containrrr/watchtower
environment:
- WATCHTOWER_NOTIFICATIONS=shoutrrr
- WATCHTOWER_NOTIFICATION_URL=generic+https://ntfy.sh/my_watchtower_topic?title=WatchtowerUpdates
```
O, si solo desea enviar notificaciones usando shoutrrr:
shoutrrr send -u "generic+https://ntfy.sh/my_watchtower_topic?title=WatchtowerUpdates" -m "testMessage"
## Sonarr, Radarr, Lidarr, Readarr, Prowlarr, SABnzbd
Es posible usar scripts personalizados para todos los servicios \*arr, además de SABnzbd. Notificaciones para descargas, advertencias, agarres, etc.
Algunos scripts bash simples para lograr esto se proporcionan amablemente en [Repositorio de nickexyz](https://github.com/nickexyz/ntfy-shellscripts).
## Nodo-ROJO
Puede utilizar el nodo de solicitud HTTP para enviar mensajes con [Nodo-ROJO](https://nodered.org), algunos ejemplos:
<details>
<summary>Example: Send a message (click to expand)</summary>
```json
[
{
"id": "c956e688cc74ad8e",
"type": "http request",
"z": "fabdd7a3.4045a",
"name": "ntfy.sh",
"method": "POST",
"ret": "txt",
"paytoqs": "ignore",
"url": "https://ntfy.sh/mytopic",
"tls": "",
"persist": false,
"proxy": "",
"authType": "",
"senderr": false,
"credentials":
{
"user": "",
"password": ""
},
"x": 590,
"y": 3160,
"wires":
[
[]
]
},
{
"id": "32ee1eade51fae50",
"type": "function",
"z": "fabdd7a3.4045a",
"name": "data",
"func": "msg.payload = \"Something happened\";\nmsg.headers = {};\nmsg.headers['tags'] = 'house';\nmsg.headers['X-Title'] = 'Home Assistant';\n\nreturn msg;",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"libs": [],
"x": 470,
"y": 3160,
"wires":
[
[
"c956e688cc74ad8e"
]
]
},
{
"id": "b287e59cd2311815",
"type": "inject",
"z": "fabdd7a3.4045a",
"name": "Manual start",
"props":
[
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": "20",
"topic": "",
"payload": "",
"payloadType": "date",
"x": 330,
"y": 3160,
"wires":
[
[
"32ee1eade51fae50"
]
]
}
]
```
</details>
![Node red message flow](static/img/nodered-message.png)
<details>
<summary>Example: Send a picture (click to expand)</summary>
```json
[
{
"id": "d135a13eadeb9d6d",
"type": "http request",
"z": "fabdd7a3.4045a",
"name": "Download image",
"method": "GET",
"ret": "bin",
"paytoqs": "ignore",
"url": "https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png",
"tls": "",
"persist": false,
"proxy": "",
"authType": "",
"senderr": false,
"credentials":
{
"user": "",
"password": ""
},
"x": 490,
"y": 3320,
"wires":
[
[
"6e75bc41d2ec4a03"
]
]
},
{
"id": "6e75bc41d2ec4a03",
"type": "function",
"z": "fabdd7a3.4045a",
"name": "data",
"func": "msg.payload = msg.payload;\nmsg.headers = {};\nmsg.headers['tags'] = 'house';\nmsg.headers['X-Title'] = 'Home Assistant - Picture';\n\nreturn msg;",
"outputs": 1,
"noerr": 0,
"initialize": "",
"finalize": "",
"libs": [],
"x": 650,
"y": 3320,
"wires":
[
[
"eb160615b6ceda98"
]
]
},
{
"id": "eb160615b6ceda98",
"type": "http request",
"z": "fabdd7a3.4045a",
"name": "ntfy.sh",
"method": "PUT",
"ret": "bin",
"paytoqs": "ignore",
"url": "https://ntfy.sh/mytopic",
"tls": "",
"persist": false,
"proxy": "",
"authType": "",
"senderr": false,
"credentials":
{
"user": "",
"password": ""
},
"x": 770,
"y": 3320,
"wires":
[
[]
]
},
{
"id": "5b8dbf15c8a7a3a5",
"type": "inject",
"z": "fabdd7a3.4045a",
"name": "Manual start",
"props":
[
{
"p": "payload"
},
{
"p": "topic",
"vt": "str"
}
],
"repeat": "",
"crontab": "",
"once": false,
"onceDelay": "20",
"topic": "",
"payload": "",
"payloadType": "date",
"x": 310,
"y": 3320,
"wires":
[
[
"d135a13eadeb9d6d"
]
]
}
]
```
</details>
![Node red picture flow](static/img/nodered-picture.png)
## Gatú
Un ejemplo para una alerta personalizada con [Gatú](https://github.com/TwiN/gatus):
```yaml
alerting:
custom:
url: "https://ntfy.sh"
method: "POST"
body: |
{
"topic": "mytopic",
"message": "[ENDPOINT_NAME] - [ALERT_DESCRIPTION]",
"title": "Gatus",
"tags": ["[ALERT_TRIGGERED_OR_RESOLVED]"],
"priority": 3
}
default-alert:
enabled: true
description: "health check failed"
send-on-resolved: true
failure-threshold: 3
success-threshold: 3
placeholders:
ALERT_TRIGGERED_OR_RESOLVED:
TRIGGERED: "warning"
RESOLVED: "white_check_mark"
```
## Jellyseerr/Overseerr webhook
Aquí hay un ejemplo para [medusa](https://github.com/Fallenbagel/jellyseerr)/[supervisor](https://overseerr.dev/) webhook
Carga útil JSON. Recuerde cambiar el `https://requests.example.com` a tu URL de jellyseerr/overseerr.
```json
{
"topic": "requests",
"title": "{{event}}",
"message": "{{subject}}\n{{message}}\n\nRequested by: {{requestedBy_username}}\n\nStatus: {{media_status}}\nRequest Id: {{request_id}}",
"priority": 4,
"attach": "{{image}}",
"click": "https://requests.example.com/{{media_type}}/{{media_tmdbid}}"
}
```
## Asistente de inicio
A continuación se muestra un ejemplo del archivo configuration.yml para configurar un componente de notificación de REST.
Dado que Home Assistant va a POST JSON, debe especificar la raíz de su recurso ntfy.
```yaml
notify:
- name: ntfy
platform: rest
method: POST_JSON
data:
topic: YOUR_NTFY_TOPIC
title_param_name: title
message_param_name: message
resource: https://ntfy.sh
```
Si necesita autenticarse en su recurso ntfy, defina la autenticación, el nombre de usuario y la contraseña como se indica a continuación:
```yaml
notify:
- name: ntfy
platform: rest
method: POST_JSON
authentication: basic
username: YOUR_USERNAME
password: YOUR_PASSWORD
data:
topic: YOUR_NTFY_TOPIC
title_param_name: title
message_param_name: message
resource: https://ntfy.sh
```
Si necesita agregar cualquier otro [Parámetros específicos de ntfy](https://ntfy.sh/docs/publish/#publish-as-json) como prioridad, etiquetas, etc., agréguelas a la `data` en el ejemplo yml. Por ejemplo:
```yaml
notify:
- name: ntfy
platform: rest
method: POST_JSON
data:
topic: YOUR_NTFY_TOPIC
priority: 4
title_param_name: title
message_param_name: message
resource: https://ntfy.sh
```
## Tiempo de actividad Kuma
Vaya a su [Tiempo de actividad Kuma](https://github.com/louislam/uptime-kuma) Configuración > Notificaciones, haga clic en **Notificación de configuración**.
A continuación, configure su deseo **título** (por ejemplo, "Uptime Kuma"), **Tema ntfy**, **URL del servidor** y **prioridad (1-5)**:
<div id="uptimekuma-screenshots" class="screenshots">
<a href="../static/img/uptimekuma-settings.png"><img src="../static/img/uptimekuma-settings.png"/></a>
<a href="../static/img/uptimekuma-setup.png"><img src="../static/img/uptimekuma-setup.png"/></a>
</div>
Ahora puede probar las notificaciones y aplicarlas a los monitores:
<div id="uptimekuma-monitor-screenshots" class="screenshots">
<a href="../static/img/uptimekuma-ios-test.jpg"><img src="../static/img/uptimekuma-ios-test.jpg"/></a>
<a href="../static/img/uptimekuma-ios-down.jpg"><img src="../static/img/uptimekuma-ios-down.jpg"/></a>
<a href="../static/img/uptimekuma-ios-up.jpg"><img src="../static/img/uptimekuma-ios-up.jpg"/></a>
</div>
## Informar
ntfy se integra de forma nativa en [Informar](https://github.com/caronc/apprise) (también echa un vistazo a la
[Página wiki de Apprise/ntfy](https://github.com/caronc/apprise/wiki/Notify_ntfy)).
Puedes usarlo así:
apprise -vv -t "Test Message Title" -b "Test Message Body" \
ntfy://mytopic
O con su propio servidor de esta manera:
apprise -vv -t "Test Message Title" -b "Test Message Body" \
ntfy://ntfy.example.com/mytopic

61
docs/faq-es.md Normal file
View file

@ -0,0 +1,61 @@
# Preguntas frecuentes (FAQ)
## ¿No es así como...?
Quién sabe. No investigué mucho antes de hacer esto. Fue divertido hacerlo.
## ¿Puedo usar esto en mi aplicación? ¿Se mantendrá gratis?
Sí. Mientras no abuses de él, estará disponible y será gratuito. No planeo monetizar
el servicio.
## ¿Cuáles son las garantías de tiempo de actividad?
El mejor esfuerzo.
## ¿Qué sucede si hay varios suscriptores al mismo tema?
Como de costumbre con pub-sub, todos los suscriptores reciben notificaciones si están suscritos a un tema.
## ¿Sabrás qué temas existen, puedes espiarme?
Si no confía en mí o sus mensajes son confidenciales, ejecute su propio servidor. Es de código abierto.
Dicho esto, los registros contienen nombres de temas y direcciones IP, pero no los uso para nada más que para nada más que
solución de problemas y limitación de velocidad. Los mensajes se almacenan en caché durante la duración configurada en `server.yml` (12h por defecto)
para facilitar los reinicios del servicio, el sondeo de mensajes y para superar las interrupciones de la red del cliente.
## ¿Puedo autoalojarlo?
Sí. El servidor (incluida esta interfaz de usuario web) se puede autohospedar y la aplicación Android/iOS admite la adición de temas desde
su propio servidor también. Echa un vistazo a la [instrucciones de instalación](install.md).
## ¿Por qué se utiliza Firebase?
Además de almacenar en caché los mensajes localmente y entregarlos a los suscriptores de sondeos largos, todos los mensajes también son
publicado en Firebase Cloud Messaging (FCM) (si `FirebaseKeyFile` está configurado, que está en ntfy.sh). Éste
es para facilitar las notificaciones en Android.
Si no te importa Firebase, te sugiero que instales el [Versión F-Droid](https://f-droid.org/en/packages/io.heckel.ntfy/)
de la aplicación y [autohospede su propio servidor ntfy](install.md).
## ¿Cuánta batería usa la aplicación de Android?
Si usa el servidor ntfy.sh y no usa el [entrega instantánea](subscribe/phone.md#instant-delivery) característica
la aplicación para Android/iOS no utiliza batería adicional, ya que se utiliza Firebase Cloud Messaging (FCM). Si utiliza su propio servidor,
o utiliza *entrega instantánea* (solo Android), la aplicación tiene que mantener una conexión constante con el servidor, lo que consume
aproximadamente 0-1% de la batería en 17h de uso (en mi teléfono). Ha habido un montón de pruebas y mejoras en torno a esto. Creo que es bonito
decente ahora.
## ¿Qué es la entrega instantánea?
[Entrega instantánea](subscribe/phone.md#instant-delivery) es una característica de la aplicación de Android. Si está activada, la aplicación mantiene una conexión constante con el
y escucha las notificaciones entrantes. Esto consume batería adicional (ver arriba),
pero entrega notificaciones al instante.
## ¿Dónde puedo donar?
Muchas personas han preguntado (¡gracias por eso!), pero actualmente no estoy aceptando ninguna donación. El costo es manejable
($ 25 / mes para el alojamiento y $ 99 / año para el certificado de Apple) en este momento, y no quiero tener que sentirme obligado a
cualquiera aceptando su dinero.
Sin embargo, puedo pedir donaciones en el futuro. Después de todo, $ 400 por año no es nada ...

92
docs/index-es.md Normal file
View file

@ -0,0 +1,92 @@
# Empezar
ntfy te permite **enviar notificaciones push a su teléfono o escritorio a través de scripts desde cualquier computadora**, utilizando HTTP PUT simple
o solicitudes POST. Lo uso para notificarme a mí mismo cuando los scripts fallan o se completan los comandos de ejecución prolongada.
## Paso 1: Obtén la aplicación
<a href="https://play.google.com/store/apps/details?id=io.heckel.ntfy"><img src="../../static/img/badge-googleplay.png"></a> <a href="https://f-droid.org/en/packages/io.heckel.ntfy/"><img src="../../static/img/badge-fdroid.png"></a> <a href="https://apps.apple.com/us/app/ntfy/id1625396347"><img src="../../static/img/badge-appstore.png"></a>
Para [recibir notificaciones en el teléfono](subscribe/phone.md), instale la aplicación, ya sea a través de Google Play o F-Droid.
Una vez instalado, ábralo y suscríbase a un tema de su elección. Los temas no tienen que crearse explícitamente, así que solo
elija un nombre y utilícelo más tarde cuando [publicar un mensaje](publish.md). Tenga en cuenta que **los nombres de los temas son públicos, por lo que es prudente
para elegir algo que no se puede adivinar fácilmente.**
Para esta guía, solo usaremos `mytopic` como nombre de nuestro tema:
<figure markdown>
![adding a topic](static/img/getting-started-add.png){ width=500 }
<figcaption>Creating/adding your first topic</figcaption>
</figure>
Eso es todo. Después de tocar "Suscribirse", la aplicación está escuchando nuevos mensajes sobre ese tema.
## Paso 2: Enviar un mensaje
Ahora vamos a [enviar un mensaje](publish.md) a nuestro tema. Es fácil en todos los idiomas, ya que solo estamos usando HTTP PUT / POST,
o con el [CLI ntfy](install.md). El mensaje está en el cuerpo de la solicitud. Aquí hay un ejemplo que muestra cómo publicar un
mensaje simple utilizando una solicitud POST:
\=== "Línea de comandos (curl)"
` curl -d "Backup successful 😀" ntfy.sh/mytopic
`
\=== "ntfy CLI"
` ntfy publish mytopic "Backup successful 😀"
`
\=== "HTTP"
''' http
POST /mytopic HTTP/1.1
Anfitrión: ntfy.sh
Backup successful 😀
```
\=== "JavaScript"
` javascript
fetch('https://ntfy.sh/mytopic', {
method: 'POST', // PUT works too
body: 'Backup successful 😀'
})
`
\=== "Go"
` go
http.Post("https://ntfy.sh/mytopic", "text/plain",
strings.NewReader("Backup successful 😀"))
`
\=== "Python"
` python
requests.post("https://ntfy.sh/mytopic",
data="Backup successful 😀".encode(encoding='utf-8'))
`
\=== "PHP"
` php-inline
file_get_contents('https://ntfy.sh/mytopic', false, stream_context_create([
'http' => [
'method' => 'POST', // PUT also works
'header' => 'Content-Type: text/plain',
'content' => 'Backup successful 😀'
]
]));
`
Esto creará una notificación que se ve así:
<figure markdown>
![basic notification](static/img/android-screenshot-basic-notification.png){ width=500 }
<figcaption>Android notification</figcaption>
</figure>
Eso es todo. Ya está todo listo. Ve a jugar y lee el resto de los documentos. Recomiendo encarecidamente leer al menos la página en
[publicar mensajes](publish.md), así como la página detallada en el [Aplicación Android/iOS](subscribe/phone.md).
Aquí hay otro video que muestra todo el proceso:
<figure>
<video controls muted autoplay loop width="650" src="static/img/android-video-overview.mp4"></video>
<figcaption>Sending push notifications to your Android phone</figcaption>
</figure>

293
docs/install-es.md Normal file
View file

@ -0,0 +1,293 @@
# Instalación de ntfy
El `ntfy` CLI le permite [publicar mensajes](publish.md), [suscribirse a temas](subscribe/cli.md) así como a
autohospede su propio servidor ntfy. Todo es bastante sencillo. Simplemente instale el binario, el paquete o la imagen de Docker,
configurarlo y ejecutarlo. Al igual que cualquier otro software. Sin pelusa.
!!! información
Los siguientes pasos solo son necesarios si desea **Autohospede su propio servidor NTFY o desea utilizar la CLI de Ntfy**.
Si solo quieres [enviar mensajes mediante ntfy.sh](publish.md), no necesita instalar nada. Puedes usar
`curl`.
## Pasos generales
El servidor ntfy viene como un binario vinculado estáticamente y se envía como paquetes tarball, deb / rpm y como una imagen docker.
Admitimos amd64, armv7 y arm64.
1. Instale ntfy mediante uno de los métodos que se describen a continuación
2. Luego (opcionalmente) editar `/etc/ntfy/server.yml` para el servidor (sólo Linux, consulte [configuración](config.md) o [ejemplo server.yml](https://github.com/binwiederhier/ntfy/blob/main/server/server.yml))
3. O (opcionalmente) crear/editar `~/.config/ntfy/client.yml` (o `/etc/ntfy/client.yml`ver [ejemplo client.yml](https://github.com/binwiederhier/ntfy/blob/main/client/client.yml))
Para ejecutar el servidor ntfy, simplemente ejecute `ntfy serve` (o `systemctl start ntfy` cuando se utiliza el deb/rpm).
Para enviar mensajes, utilice `ntfy publish`. Para suscribirse a temas, utilice `ntfy subscribe` (consulte \[suscripción a través de CLI]\[subscribe/cli.md]
para más detalles).
## Binarios de Linux
Por favor, echa un vistazo a la [página de lanzamientos](https://github.com/binwiederhier/ntfy/releases) para binarios y
paquetes deb/rpm.
\=== "x86\_64/amd64"
` bash
wget https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_x86_64.tar.gz
tar zxvf ntfy_1.27.2_linux_x86_64.tar.gz
sudo cp -a ntfy_1.27.2_linux_x86_64/ntfy /usr/bin/ntfy
sudo mkdir /etc/ntfy && sudo cp ntfy_1.27.2_linux_x86_64/{client,server}/*.yml /etc/ntfy
sudo ntfy serve
`
\=== "armv6"
` bash
wget https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_armv6.tar.gz
tar zxvf ntfy_1.27.2_linux_armv6.tar.gz
sudo cp -a ntfy_1.27.2_linux_armv6/ntfy /usr/bin/ntfy
sudo mkdir /etc/ntfy && sudo cp ntfy_1.27.2_linux_armv6/{client,server}/*.yml /etc/ntfy
sudo ntfy serve
`
\=== "armv7/armhf"
` bash
wget https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_armv7.tar.gz
tar zxvf ntfy_1.27.2_linux_armv7.tar.gz
sudo cp -a ntfy_1.27.2_linux_armv7/ntfy /usr/bin/ntfy
sudo mkdir /etc/ntfy && sudo cp ntfy_1.27.2_linux_armv7/{client,server}/*.yml /etc/ntfy
sudo ntfy serve
`
\=== "arm64"
` bash
wget https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_arm64.tar.gz
tar zxvf ntfy_1.27.2_linux_arm64.tar.gz
sudo cp -a ntfy_1.27.2_linux_arm64/ntfy /usr/bin/ntfy
sudo mkdir /etc/ntfy && sudo cp ntfy_1.27.2_linux_arm64/{client,server}/*.yml /etc/ntfy
sudo ntfy serve
`
## Repositorio Debian/Ubuntu
Instalación a través del repositorio de Debian:
\=== "x86\_64/amd64"
` bash
curl -sSL https://archive.heckel.io/apt/pubkey.txt | sudo apt-key add -
sudo apt install apt-transport-https
sudo sh -c "echo 'deb [arch=amd64] https://archive.heckel.io/apt debian main' \ > /etc/apt/sources.list.d/archive.heckel.io.list"
sudo apt update
sudo apt install ntfy
sudo systemctl enable ntfy
sudo systemctl start ntfy
`
\=== "armv7/armhf"
` bash
curl -sSL https://archive.heckel.io/apt/pubkey.txt | sudo apt-key add -
sudo apt install apt-transport-https
sudo sh -c "echo 'deb [arch=armhf] https://archive.heckel.io/apt debian main' \ > /etc/apt/sources.list.d/archive.heckel.io.list"
sudo apt update
sudo apt install ntfy
sudo systemctl enable ntfy
sudo systemctl start ntfy
`
\=== "arm64"
` bash
curl -sSL https://archive.heckel.io/apt/pubkey.txt | sudo apt-key add -
sudo apt install apt-transport-https
sudo sh -c "echo 'deb [arch=arm64] https://archive.heckel.io/apt debian main' \ > /etc/apt/sources.list.d/archive.heckel.io.list"
sudo apt update
sudo apt install ntfy
sudo systemctl enable ntfy
sudo systemctl start ntfy
`
Instalación manual del archivo .deb:
\=== "x86\_64/amd64"
` bash
wget https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_amd64.deb
sudo dpkg -i ntfy_*.deb
sudo systemctl enable ntfy
sudo systemctl start ntfy
`
\=== "armv6"
` bash
wget https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_armv6.deb
sudo dpkg -i ntfy_*.deb
sudo systemctl enable ntfy
sudo systemctl start ntfy
`
\=== "armv7/armhf"
` bash
wget https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_armv7.deb
sudo dpkg -i ntfy_*.deb
sudo systemctl enable ntfy
sudo systemctl start ntfy
`
\=== "arm64"
` bash
wget https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_arm64.deb
sudo dpkg -i ntfy_*.deb
sudo systemctl enable ntfy
sudo systemctl start ntfy
`
## Fedora/RHEL/CentOS
\=== "x86\_64/amd64"
` bash
sudo rpm -ivh https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_amd64.rpm
sudo systemctl enable ntfy
sudo systemctl start ntfy
`
\=== "armv6"
` bash
sudo rpm -ivh https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_armv6.rpm
sudo systemctl enable ntfy
sudo systemctl start ntfy
`
\=== "armv7/armhf"
` bash
sudo rpm -ivh https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_armv7.rpm
sudo systemctl enable ntfy
sudo systemctl start ntfy
`
\=== "arm64"
` bash
sudo rpm -ivh https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_linux_arm64.rpm
sudo systemctl enable ntfy
sudo systemctl start ntfy
`
## Arch Linux
ntfy se puede instalar mediante un [Paquete AUR](https://aur.archlinux.org/packages/ntfysh-bin/). Puede utilizar un [Ayudante de AUR](https://wiki.archlinux.org/title/AUR_helpers) gustar `paru`, `yay` u otros para descargar, construir e instalar ntfy y mantenerlo actualizado.
paru -S ntfysh-bin
Como alternativa, ejecute los siguientes comandos para instalar ntfy manualmente:
curl https://aur.archlinux.org/cgit/aur.git/snapshot/ntfysh-bin.tar.gz | tar xzv
cd ntfysh-bin
makepkg -si
## NixOS / Nix
ntfy está empaquetado en nixpkgs como `ntfy-sh`. Se puede instalar agregando el nombre del paquete al archivo de configuración y llamando `nixos-rebuild`. Como alternativa, se puede utilizar el siguiente comando para instalar ntfy en el entorno de usuario actual:
nix-env -iA ntfy-sh
## macOS
El [CLI ntfy](subscribe/cli.md) (`ntfy publish` y `ntfy subscribe` only) también es compatible con macOS.
Para instalar, por favor [descargar el tarball](https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy\_1.27.2\_macOS_all.tar.gz),
extráelo y colóquelo en algún lugar de su `PATH` (por ejemplo, `/usr/local/bin/ntfy`).
Si se ejecuta como `root`, ntfy buscará su configuración en `/etc/ntfy/client.yml`. Para todos los demás usuarios, lo buscará en
`~/Library/Application Support/ntfy/client.yml` (muestra incluida en el tarball).
```bash
curl -L https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy_1.27.2_macOS_all.tar.gz > ntfy_1.27.2_macOS_all.tar.gz
tar zxvf ntfy_1.27.2_macOS_all.tar.gz
sudo cp -a ntfy_1.27.2_macOS_all/ntfy /usr/local/bin/ntfy
mkdir ~/Library/Application\ Support/ntfy
cp ntfy_1.27.2_macOS_all/client/client.yml ~/Library/Application\ Support/ntfy/client.yml
ntfy --help
```
!!! información
Hay un [Problema de GitHub](https://github.com/binwiederhier/ntfy/issues/286) acerca de cómo hacer que ntfy sea instalable a través de
[Homebrew](https://brew.sh/). Eventualmente llegaré a eso, pero también me encantaría que alguien más se acercara para hacerlo.
Además, también puede compilar y ejecutar el servidor ntfy en macOS, aunque oficialmente no lo admito.
Echa un vistazo a la [instrucciones de compilación](develop.md) para más detalles.
## Windows
El [CLI ntfy](subscribe/cli.md) (`ntfy publish` y `ntfy subscribe` only) también es compatible con Windows.
Para instalar, por favor [descargue el último zip](https://github.com/binwiederhier/ntfy/releases/download/v1.27.2/ntfy\_1.27.2\_windows_x86\_64.zip),
extraerlo y colocar el `ntfy.exe` binario en algún lugar de su `%Path%`.
La ruta predeterminada para el archivo de configuración del cliente es en `%AppData%\ntfy\client.yml` (no creado automáticamente, muestra en el archivo ZIP).
También disponible en [Scoop's](https://scoop.sh) Repositorio principal:
`scoop install ntfy`
!!! información
Actualmente no hay ningún instalador para Windows y el binario no está firmado. Si esto se desea, por favor cree un
[Problema de GitHub](https://github.com/binwiederhier/ntfy/issues) para hacérmelo saber.
## Estibador
El [Imagen ntfy](https://hub.docker.com/r/binwiederhier/ntfy) está disponible para amd64, armv6, armv7 y arm64. Debería
ser bastante sencillo de usar.
El servidor expone su interfaz de usuario web y la API en el puerto 80, por lo que debe exponerlo en Docker. Para utilizar la persistencia
[caché de mensajes](config.md#message-cache), también debe asignar un volumen a `/var/cache/ntfy`. Para cambiar otros ajustes,
debe mapear `/etc/ntfy`, para que pueda editar `/etc/ntfy/server.yml`.
Uso básico (sin caché ni configuración adicional):
docker run -p 80:80 -it binwiederhier/ntfy serve
Con caché persistente (configurada como argumentos de línea de comandos):
```bash
docker run \
-v /var/cache/ntfy:/var/cache/ntfy \
-p 80:80 \
-it \
binwiederhier/ntfy \
serve \
--cache-file /var/cache/ntfy/cache.db
```
Con otras opciones de configuración, zona horaria y usuario no root (configurado a través de `/etc/ntfy/server.yml`ver [configuración](config.md) para más detalles):
```bash
docker run \
-v /etc/ntfy:/etc/ntfy \
-e TZ=UTC \
-p 80:80 \
-u UID:GID \
-it \
binwiederhier/ntfy \
serve
```
Uso de docker-compose con un usuario no root:
```yaml
version: "2.1"
services:
ntfy:
image: binwiederhier/ntfy
container_name: ntfy
command:
- serve
environment:
- TZ=UTC # optional: set desired timezone
user: UID:GID # optional: replace with your own user/group or uid/gid
volumes:
- /var/cache/ntfy:/var/cache/ntfy
- /etc/ntfy:/etc/ntfy
ports:
- 80:80
restart: unless-stopped
```
Si utiliza un usuario no root al ejecutar la versión de Docker, asegúrese de chown los archivos server.yml, user.db y cache.db en el mismo uid/gid.
Como alternativa, es posible que desee crear una imagen de Docker personalizada que se pueda ejecutar con menos argumentos de línea de comandos y sin entregar el archivo de configuración por separado.
FROM binwiederhier/ntfy
COPY server.yml /etc/ntfy/server.yml
ENTRYPOINT ["ntfy", "serve"]
Esta imagen se puede enviar a un registro de contenedores y enviarse de forma independiente. Todo lo que se necesita al ejecutarlo es asignar el puerto de ntfy a un puerto host.

12
docs/privacy-es.md Normal file
View file

@ -0,0 +1,12 @@
# Política de privacidad
Me encanta el software libre, y lo hago porque es divertido. No tengo malas intenciones, y **Lo haré
nunca monetice ni venda su información, y este servicio y software siempre permanecerán gratuitos y abiertos.**
Ni el servidor ni la aplicación registran ninguna información personal, ni comparten ninguno de los mensajes y temas con
cualquier servicio externo. Todos los datos se utilizan exclusivamente para que el servicio funcione correctamente. El único servicio externo
Utilizo el servicio Firebase Cloud Messaging (FCM), que es necesario para proporcionar notificaciones instantáneas de Android (consulte
[PREGUNTAS MÁS FRECUENTES](faq.md) para más detalles). Para evitar FCM por completo, descargue la versión F-Droid.
Para fines de depuración, el servidor ntfy puede registrar temporalmente rutas de solicitud, direcciones IP remotas o incluso temas
o mensajes, aunque normalmente esto está desactivado.

2721
docs/publish-es.md Normal file
View file

File diff suppressed because it is too large Load diff

752
docs/releases-es.md Normal file
View file

@ -0,0 +1,752 @@
# Notas
Los binarios para todas las versiones se pueden encontrar en las páginas de versiones de GitHub para el [Servidor ntfy](https://github.com/binwiederhier/ntfy/releases)
y el [Aplicación ntfy para Android](https://github.com/binwiederhier/ntfy-android/releases).
<!--
## ntfy Android app v1.14.0 (UNRELEASED)
**Features:**
* Polling is now done with since=<id> API, which makes deduping easier ([#165](https://github.com/binwiederhier/ntfy/issues/165))
* Turned JSON stream deprecation banner into "Use WebSockets" banner (no ticket)
**Bugs:**
* Long-click selecting of notifications doesn't scoll to the top anymore ([#235](https://github.com/binwiederhier/ntfy/issues/235), thanks to [@wunter8](https://github.com/wunter8))
* Add attachment and click URL extras to MESSAGE_RECEIVED broadcast ([#329](https://github.com/binwiederhier/ntfy/issues/329), thanks to [@wunter8](https://github.com/wunter8))
* Accessibility: Clear/choose service URL button in base URL dropdown now has a label ([#292](https://github.com/binwiederhier/ntfy/issues/292), thanks to [@mhameed](https://github.com/mhameed) for reporting)
**Additional translations:**
* Italian (thanks to [@Genio2003](https://hosted.weblate.org/user/Genio2003/))
* Dutch (thanks to [@SchoNie](https://hosted.weblate.org/user/SchoNie/))
Thank you to [@wunter8](https://github.com/wunter8) for proactively picking up some Android tickets, and fixing them! You rock!
-->
## Servidor ntfy v1.27.2
Publicado el June 23, 2022
Esta versión trae dos nuevas opciones de CLI para esperar a que finalice un comando o a que salga un PID. También añade más detalles
para realizar un seguimiento de los resultados de depuración. Aparte de otros errores, corrige un problema de rendimiento que se produjo en grandes instalaciones cada vez
minuto más o menos, debido a la recopilación de estadísticas de la competencia (las instalaciones personales probablemente no se verán afectadas por esto).
**Funciones:**
* Agregar `cache-startup-queries` opción para permitir la personalización [Ajuste del rendimiento de SQLite](config.md#wal-for-message-cache) (sin billete)
* ntfy CLI ahora puede [Espere un comando o PID](subscribe/cli.md#wait-for-pidcommand) antes de publicar ([#263](https://github.com/binwiederhier/ntfy/issues/263), gracias a la [ntfy original](https://github.com/dschep/ntfy) para la idea)
* Seguimiento: registre toda la solicitud HTTP para simplificar la depuración (sin vale)
* Permitir la configuración de la contraseña de usuario a través de `NTFY_PASSWORD` Variable env ([#327](https://github.com/binwiederhier/ntfy/pull/327)gracias a [@Kenix3](https://github.com/Kenix3))
**Bugs:**
* Corregir solicitudes lentas debido a un bloqueo excesivo ([#338](https://github.com/binwiederhier/ntfy/issues/338))
* Devolver HTTP 500 para `GET /_matrix/push/v1/notify` cuando `base-url` no está configurado (sin ticket)
* No permitir la configuración `upstream-base-url` al mismo valor que `base-url` ([#334](https://github.com/binwiederhier/ntfy/issues/334)gracias a [@oester](https://github.com/oester) para la presentación de informes)
* Arreglar `since=<id>` implementación para múltiples temas ([#336](https://github.com/binwiederhier/ntfy/issues/336)gracias a [@karmanyaahm](https://github.com/karmanyaahm) para la presentación de informes)
* Análisis sencillo `Actions` encabezado ahora es compatible con la configuración de Android `intent=` clave ([#341](https://github.com/binwiederhier/ntfy/pull/341)gracias a [@wunter8](https://github.com/wunter8))
**Obsolescencias:**
* El `ntfy publish --env-topic` La opción está en desuso a partir de ahora (consulte [obsolescencias](deprecations.md) para más detalles)
## Servidor ntfy v1.26.0
Publicado el June 16, 2022
Esta versión agrega una Matrix Push Gateway directamente en ntfy, para facilitar el autoalojamiento de un servidor Matrix. Las ventanas
CLI ahora está disponible a través de Scoop, y ntfy ahora es compatible de forma nativa en Uptime Kuma.
**Funciones:**
* ntfy ahora es un [Puerta de enlace push de matriz](https://spec.matrix.org/v1.2/push-gateway-api/) (en combinación con [UnifiedPush](https://unifiedpush.org) como el [Protocolo push del proveedor](https://unifiedpush.org/developers/gateway/), [#319](https://github.com/binwiederhier/ntfy/issues/319)/[#326](https://github.com/binwiederhier/ntfy/pull/326)gracias a [@MayeulC](https://github.com/MayeulC) para la presentación de informes)
* La CLI de Windows ya está disponible a través de [Cuchara](https://scoop.sh) ([ScoopInstaller#3594](https://github.com/ScoopInstaller/Main/pull/3594), [#311](https://github.com/binwiederhier/ntfy/pull/311), [#269](https://github.com/binwiederhier/ntfy/issues/269)gracias a [@kzshantonu](https://github.com/kzshantonu))
* [Tiempo de actividad Kuma](https://github.com/louislam/uptime-kuma) ahora permite publicar en ntfy ([tiempo de actividad-kuma#1674](https://github.com/louislam/uptime-kuma/pull/1674)gracias a [@philippdormann](https://github.com/philippdormann))
* Mostrar la versión ntfy en `ntfy serve` comando ([#314](https://github.com/binwiederhier/ntfy/issues/314)gracias a [@poblabs](https://github.com/poblabs))
**Bugs:**
* Aplicación web: Mostrar la alerta "notificaciones no compatibles" en HTTP ([#323](https://github.com/binwiederhier/ntfy/issues/323)gracias a [@milksteakjellybeans](https://github.com/milksteakjellybeans) para la presentación de informes)
* Usar la última dirección en `X-Forwarded-For` encabezado como dirección del visitante ([#328](https://github.com/binwiederhier/ntfy/issues/328))
**Documentación**
* Añadido [ejemplo](examples.md) para [Tiempo de actividad Kuma](https://github.com/louislam/uptime-kuma) integración ([#315](https://github.com/binwiederhier/ntfy/pull/315)gracias a [@philippdormann](https://github.com/philippdormann))
* Corregir las instrucciones de instalación de Docker ([#320](https://github.com/binwiederhier/ntfy/issues/320)gracias a [@milksteakjellybeans](https://github.com/milksteakjellybeans) para la presentación de informes)
* Añadir comentarios aclaratorios a base-url ([#322](https://github.com/binwiederhier/ntfy/issues/322)gracias a [@milksteakjellybeans](https://github.com/milksteakjellybeans) para la presentación de informes)
* Actualizar preguntas frecuentes para la aplicación iOS ([#321](https://github.com/binwiederhier/ntfy/issues/321)gracias a [@milksteakjellybeans](https://github.com/milksteakjellybeans) para la presentación de informes)
## Aplicación ntfy iOS v1.2
Publicado el June 16, 2022
Esta versión agrega compatibilidad con la autenticación/autorización para servidores autohospedados. También le permite
establezca el servidor como el servidor predeterminado para los nuevos temas.
**Funciones:**
* Compatibilidad con la autenticación y la gestión de usuarios ([#277](https://github.com/binwiederhier/ntfy/issues/277))
* Posibilidad de agregar el servidor predeterminado ([#295](https://github.com/binwiederhier/ntfy/issues/295))
**Bugs:**
* Agregar validación para la URL del servidor autohospedada ([#290](https://github.com/binwiederhier/ntfy/issues/290))
## Servidor ntfy v1.25.2
Publicado el 2 de junio de 2022
Esta versión agrega la capacidad de establecer un nivel de registro para facilitar la depuración de sistemas activos. También resuelve un
problema de producción con algunos usuarios excesivos que dio lugar a problemas de cuota de Firebase (solo se aplica a los usuarios excesivos).
Ahora bloqueamos a los visitantes para que no usen Firebase si activan una respuesta excedida de cuota.
Además de eso, actualizamos el SDK de Firebase y ahora estamos creando la versión en GitHub Actions. También tenemos dos
más traducciones: chino/simplificado y holandés.
**Funciones:**
* Registro avanzado, con diferentes niveles de registro y recarga en caliente del nivel de registro ([#284](https://github.com/binwiederhier/ntfy/pull/284))
**Bugs**:
* Respetar la respuesta de "cuota excedida" de Firebase para los temas, bloquear la publicación de Firebase para el usuario durante 10 minutos ([#289](https://github.com/binwiederhier/ntfy/issues/289))
* Corregir el encabezado de la documentación del encabezado azul debido a la actualización del tema mkdocs-material (sin ticket)
**Mantenimiento:**
* Actualizar Firebase Admin SDK a 4.x ([#274](https://github.com/binwiederhier/ntfy/issues/274))
* CI: Construir a partir de canalización en lugar de localmente ([#36](https://github.com/binwiederhier/ntfy/issues/36))
**Documentación**:
* ⚠️ [Política de privacidad](privacy.md) actualizado para reflejar la función adicional de depuración/seguimiento (sin vale)
* [Ejemplos](examples.md) para [Asistente de inicio](https://www.home-assistant.io/) ([#282](https://github.com/binwiederhier/ntfy/pull/282)gracias a [@poblabs](https://github.com/poblabs))
* Instrucciones de instalación para [NixOS/Nix](https://ntfy.sh/docs/install/#nixos-nix) ([#282](https://github.com/binwiederhier/ntfy/pull/282)gracias a [@arjan-s](https://github.com/arjan-s))
* Aclarar `poll_request` redacción para [Notificaciones push de iOS](https://ntfy.sh/docs/config/#ios-instant-notifications) ([#300](https://github.com/binwiederhier/ntfy/issues/300)gracias a [@prabirshrestha](https://github.com/prabirshrestha) para la presentación de informes)
* Ejemplo de uso de ntfy con docker-compose.yml sin privilegios de root ([#304](https://github.com/binwiederhier/ntfy/pull/304)gracias a [@ksurl](https://github.com/ksurl))
**Traducciones adicionales:**
* Chino/Simplificado (gracias a [@yufei.im](https://hosted.weblate.org/user/yufei.im/))
* Holandés (gracias a [@SchoNie](https://hosted.weblate.org/user/SchoNie/))
## Aplicación ntfy iOS v1.1
Lanzamiento 31 May 2022
En esta versión de la aplicación iOS, agregamos prioridades de mensajes (asignadas a niveles de interrupción de iOS), etiquetas y emojis,
botones de acción para abrir sitios web o realizar solicitudes HTTP (en la vista de notificación y detalles), un clic personalizado
acción cuando se pulsa la notificación y varias otras correcciones.
También agrega soporte para servidores autohospedados (aunque aún no admite autenticación). El servidor autohospedado debe ser
configurado para reenviar solicitudes de sondeo a ntfy.sh ascendentes para que las notificaciones push funcionen (consulte [Notificaciones push de iOS](https://ntfy.sh/docs/config/#ios-instant-notifications)
para más detalles).
**Funciones:**
* [Prioridad del mensaje](https://ntfy.sh/docs/publish/#message-priority) soporte (sin ticket)
* [Etiquetas/emojis](https://ntfy.sh/docs/publish/#tags-emojis) soporte (sin ticket)
* [Botones de acción](https://ntfy.sh/docs/publish/#action-buttons) soporte (sin ticket)
* [Haga clic en la acción](https://ntfy.sh/docs/publish/#click-action) soporte (sin ticket)
* Abrir tema cuando se hace clic en la notificación (sin ticket)
* La notificación ahora hace un sonido y vibra (sin ticket)
* Cancelar notificaciones al navegar al tema (sin ticket)
* Compatibilidad con iOS 14.0 (sin ticket, [PR#1](https://github.com/binwiederhier/ntfy-ios/pull/1)gracias a [@callum-99](https://github.com/callum-99))
**Bugs:**
* La interfaz de usuario de iOS no siempre se actualiza correctamente ([#267](https://github.com/binwiederhier/ntfy/issues/267))
## Servidor ntfy v1.24.0
Lanzamiento 28 May 2022
Esta versión del servidor ntfy trae características compatibles para la aplicación ntfy iOS. Lo más importante es que
permite la compatibilidad con servidores autohospedados en combinación con la aplicación iOS. Esto es para superar lo restrictivo
Entorno de desarrollo de Apple.
**Funciones:**
* Envía regularmente mensajes keepalive de Firebase a ~poll topic para admitir servidores autohospedados (sin ticket)
* Agregar filtro de suscripción para consultar mensajes exactos por ID (sin ticket)
* Soporte para `poll_request` mensajes para apoyar [Notificaciones push de iOS](https://ntfy.sh/docs/config/#ios-instant-notifications) para servidores autohospedados (sin vale)
**Bugs:**
* Correos electrónicos de soporte sin `Content-Type` ([#265](https://github.com/binwiederhier/ntfy/issues/265)gracias a [@dmbonsall](https://github.com/dmbonsall))
**Traducciones adicionales:**
* Italiano (gracias a [@Genio2003](https://hosted.weblate.org/user/Genio2003/))
## ntfy aplicación iOS v1.0
Lanzamiento 25 May 2022
Esta es la primera versión de la aplicación ntfy para iOS. Solo admite ntfy.sh (sin servidores autohospedados) y solo mensajes + título
(sin prioridad, etiquetas, archivos adjuntos, ...). Agregaré rápidamente (con suerte) la mayoría de las otras características de ntfy, y luego me enfocaré
en servidores autohospedados.
La aplicación ya está disponible en el [Tienda de aplicaciones](https://apps.apple.com/us/app/ntfy/id1625396347).
**Entradas:**
* Aplicación iOS ([#4](https://github.com/binwiederhier/ntfy/issues/4), véase también: [Resumen de TestFlight](https://github.com/binwiederhier/ntfy/issues/4#issuecomment-1133767150))
**Gracias:**
* Gracias a todos los probadores que probaron la aplicación. Ustedes me dieron la confianza de que está listo para lanzar (aunque con
algunos problemas conocidos que se abordarán en las versiones de seguimiento).
## Servidor ntfy v1.23.0
Lanzamiento 21 May 2022
Esta versión incluye una CLI para Windows y macOS, así como la capacidad de deshabilitar la aplicación web por completo. Además de eso,
agrega soporte para APNs, el servicio de mensajería de iOS. Esto es necesario para la aplicación iOS (que pronto se lanzará).
**Funciones:**
* [Windows](https://ntfy.sh/docs/install/#windows) y [macOS](https://ntfy.sh/docs/install/#macos) compilaciones para el [CLI ntfy](https://ntfy.sh/docs/subscribe/cli/) ([#112](https://github.com/binwiederhier/ntfy/issues/112))
* Posibilidad de deshabilitar la aplicación web por completo ([#238](https://github.com/binwiederhier/ntfy/issues/238)/[#249](https://github.com/binwiederhier/ntfy/pull/249)gracias a [@Curid](https://github.com/Curid))
* Agregar configuración de APNs a los mensajes de Firebase para admitir [Aplicación iOS](https://github.com/binwiederhier/ntfy/issues/4) ([#247](https://github.com/binwiederhier/ntfy/pull/247)gracias a [@Copephobia](https://github.com/Copephobia))
**Bugs:**
* Admite guiones bajos en las opciones de configuración de server.yml ([#255](https://github.com/binwiederhier/ntfy/issues/255)gracias a [@ajdelgado](https://github.com/ajdelgado))
* Forzar MAKEFLAGS a --jobs=1 en `Makefile` ([#257](https://github.com/binwiederhier/ntfy/pull/257)gracias a [@oddlama](https://github.com/oddlama))
**Documentación:**
* Error tipográfico en las instrucciones de instalación ([#252](https://github.com/binwiederhier/ntfy/pull/252)/[#251](https://github.com/binwiederhier/ntfy/issues/251)gracias a [@oddlama](https://github.com/oddlama))
* Corregir error tipográfico en el ejemplo de servidor privado ([#262](https://github.com/binwiederhier/ntfy/pull/262)gracias a [@MayeulC](https://github.com/MayeulC))
* [Ejemplos](examples.md) para [medusa](https://github.com/Fallenbagel/jellyseerr)/[supervisor](https://overseerr.dev/) ([#264](https://github.com/binwiederhier/ntfy/pull/264)gracias a [@Fallenbagel](https://github.com/Fallenbagel))
**Traducciones adicionales:**
* Portugués/Brasil (gracias a [@tiagotriques](https://hosted.weblate.org/user/tiagotriques/) y [@pireshenrique22](https://hosted.weblate.org/user/pireshenrique22/))
Gracias a los muchos traductores, que ayudaron a traducir las nuevas cadenas tan rápidamente. Me siento honrado y sorprendido por su ayuda.
## ntfy Aplicación android v1.13.0
Lanzamiento 11 May 2022
Esta versión trae un diseño ligeramente alterado para la vista de detalles, con un diseño de tarjeta para hacer notificaciones más fácilmente.
distinguibles entre sí. También envía configuraciones por tema que permiten anular la prioridad mínima, el umbral de eliminación automática
e iconos personalizados. Aparte de eso, tenemos toneladas de correcciones de errores como de costumbre.
**Funciones:**
* Configuración por suscripción, iconos de suscripción personalizados ([#155](https://github.com/binwiederhier/ntfy/issues/155)gracias a [@mztiq](https://github.com/mztiq) para la presentación de informes)
* Tarjetas en vista de detalle de notificación ([#175](https://github.com/binwiederhier/ntfy/issues/175)gracias a [@cmeis](https://github.com/cmeis) para la presentación de informes)
**Bugs:**
* Denominación precisa de "notificaciones de silencio" de "notificaciones de pausa" ([#224](https://github.com/binwiederhier/ntfy/issues/224)gracias a [@shadow00](https://github.com/shadow00) para la presentación de informes)
* Hacer que los mensajes con enlaces sean seleccionables ([#226](https://github.com/binwiederhier/ntfy/issues/226)gracias a [@StoyanDimitrov](https://github.com/StoyanDimitrov) para la presentación de informes)
* Restaurar temas o configuraciones desde la copia de seguridad no funciona ([#223](https://github.com/binwiederhier/ntfy/issues/223)gracias a [@shadow00](https://github.com/shadow00) para la presentación de informes)
* Corregir el icono de la aplicación en versiones antiguas de Android ([#128](https://github.com/binwiederhier/ntfy/issues/128)gracias a [@shadow00](https://github.com/shadow00) para la presentación de informes)
* Arreglar carreras en el registro de UnifiedPush ([#230](https://github.com/binwiederhier/ntfy/issues/230), gracias a @Jakob por informar)
* Evitar que la acción de vista bloquee la aplicación ([#233](https://github.com/binwiederhier/ntfy/issues/233))
* Evitar que los nombres e iconos de temas largos se superpongan ([#240](https://github.com/binwiederhier/ntfy/issues/240)gracias a [@cmeis](https://github.com/cmeis) para la presentación de informes)
**Traducciones adicionales:**
* Holandés (*incompleto*gracias a [@diony](https://hosted.weblate.org/user/diony/))
**Gracias:**
Gracias a [@cmeis](https://github.com/cmeis), [@StoyanDimitrov](https://github.com/StoyanDimitrov), [@Fallenbagel](https://github.com/Fallenbagel) para las pruebas, y
Para [@Joeharrison94](https://github.com/Joeharrison94) para la entrada. Y muchas gracias a todos los traductores por ponerse al día tan rápido.
## Servidor ntfy v1.22.0
Lanzamiento 7 May 2022
Esta versión hace que la aplicación web sea más accesible para las personas con discapacidades e introduce un icono de "marcar como leída" en la aplicación web.
También corrige un curioso error con WebSockets y Apache y hace que los sonidos de notificación en la aplicación web sean un poco más silenciosos.
También hemos mejorado un poco la documentación y hemos añadido traducciones para tres idiomas más.
**Funciones:**
* Hacer que la aplicación web sea más accesible ([#217](https://github.com/binwiederhier/ntfy/issues/217))
* Mejor análisis de las acciones del usuario, permitiendo cotizaciones (sin ticket)
* Agregue el botón de icono "marcar como leído" a la notificación ([#243](https://github.com/binwiederhier/ntfy/pull/243)gracias a [@wunter8](https://github.com/wunter8))
**Bugs:**
* `Upgrade` La comprobación del encabezado ahora distingue entre mayúsculas y minúsculas ([#228](https://github.com/binwiederhier/ntfy/issues/228)gracias a [@wunter8](https://github.com/wunter8) para encontrarlo)
* Hecho que la aplicación web suene más silenciosa ([#222](https://github.com/binwiederhier/ntfy/issues/222))
* Agregar un mensaje de error específico de "navegación privada" para Firefox/Safari ([#208](https://github.com/binwiederhier/ntfy/issues/208)gracias a [@julianfoad](https://github.com/julianfoad) para la presentación de informes)
**Documentación:**
* Configuración de caddy mejorada (sin ticket, gracias a @Stnby)
* Ejemplos adicionales de varias líneas en el [publicar página](https://ntfy.sh/docs/publish/) ([#234](https://github.com/binwiederhier/ntfy/pull/234)gracias a [@aTable](https://github.com/aTable))
* Se ha corregido el ejemplo de autenticación de PowerShell para usar UTF-8 ([#242](https://github.com/binwiederhier/ntfy/pull/242)gracias a [@SMAW](https://github.com/SMAW))
**Traducciones adicionales:**
* Checo (gracias a [@waclaw66](https://hosted.weblate.org/user/waclaw66/))
* Francés (gracias a [@nathanaelhoun](https://hosted.weblate.org/user/nathanaelhoun/))
* Húngaro (gracias a [@agocsdaniel](https://hosted.weblate.org/user/agocsdaniel/))
**Gracias por probar:**
Gracias a [@wunter8](https://github.com/wunter8) para pruebas.
## ntfy Aplicación android v1.12.0
Lanzamiento 25 Abr 2022
La característica principal de esta versión de Android es [Botones de acción](https://ntfy.sh/docs/publish/#action-buttons), una característica
que permite a los usuarios añadir acciones a las notificaciones. Las acciones pueden ser ver un sitio web o una aplicación, enviar una transmisión o
enviar una solicitud HTTP.
También agregamos soporte para [ntfy:// enlaces profundos](https://ntfy.sh/docs/subscribe/phone/#ntfy-links), añadidas tres más
y se han corregido un montón de errores.
**Funciones:**
* Notificación personalizada [botones de acción](https://ntfy.sh/docs/publish/#action-buttons) ([#134](https://github.com/binwiederhier/ntfy/issues/134),
gracias a [@mrherman](https://github.com/mrherman) para la presentación de informes)
* Soporte para [ntfy:// enlaces profundos](https://ntfy.sh/docs/subscribe/phone/#ntfy-links) ([#20](https://github.com/binwiederhier/ntfy/issues/20)gracias
Para [@Copephobia](https://github.com/Copephobia) para la presentación de informes)
* [Metadatos de Fastlane](https://hosted.weblate.org/projects/ntfy/android-fastlane/) ahora también se puede traducir ([#198](https://github.com/binwiederhier/ntfy/issues/198),
gracias a [@StoyanDimitrov](https://github.com/StoyanDimitrov) para la presentación de informes)
* Opción de configuración de canal para configurar la anulación de DND, sonidos, etc. ([#91](https://github.com/binwiederhier/ntfy/issues/91))
**Bugs:**
* Validar direcciones URL al cambiar el servidor y el servidor predeterminados en la administración de usuarios ([#193](https://github.com/binwiederhier/ntfy/issues/193),
gracias a [@StoyanDimitrov](https://github.com/StoyanDimitrov) para la presentación de informes)
* Error al enviar la notificación de prueba en diferentes idiomas ([#209](https://github.com/binwiederhier/ntfy/issues/209),
gracias a [@StoyanDimitrov](https://github.com/StoyanDimitrov) para la presentación de informes)
* La casilla de verificación "\[x] Entrega instantánea en modo doze" no funciona correctamente ([#211](https://github.com/binwiederhier/ntfy/issues/211))
* No permitir acciones GET/HEAD "http" con el cuerpo ([#221](https://github.com/binwiederhier/ntfy/issues/221)gracias a
[@cmeis](https://github.com/cmeis) para la presentación de informes)
* La acción "view" con "clear=true" no funciona en algunos teléfonos ([#220](https://github.com/binwiederhier/ntfy/issues/220)gracias a
[@cmeis](https://github.com/cmeis) para la presentación de informes)
* No agrupe la notificación de servicio en primer plano con otros ([#219](https://github.com/binwiederhier/ntfy/issues/219)gracias a
[@s-h-a-r-d](https://github.com/s-h-a-r-d) para la presentación de informes)
**Traducciones adicionales:**
* Checo (gracias a [@waclaw66](https://hosted.weblate.org/user/waclaw66/))
* Francés (gracias a [@nathanaelhoun](https://hosted.weblate.org/user/nathanaelhoun/))
* Japonés (gracias a [@shak](https://hosted.weblate.org/user/shak/))
* Ruso (gracias a [@flamey](https://hosted.weblate.org/user/flamey/) y [@ilya.mikheev.coder](https://hosted.weblate.org/user/ilya.mikheev.coder/))
**Gracias por probar:**
Gracias a [@s-h-a-r-d](https://github.com/s-h-a-r-d) (también conocido como @Shard), [@cmeis](https://github.com/cmeis),
@poblabs, y todos los que olvidé para probar.
## Servidor ntfy v1.21.2
Lanzamiento 24 Abr 2022
En esta versión, la aplicación web obtuvo soporte de traducción y ya 🇧🇬 🇩🇪 🇺🇸 🌎 se tradujo a 9 idiomas.
También vuelve a agregar soporte para ARMv6 y agrega soporte del lado del servidor para botones de acción. [Botones de acción](https://ntfy.sh/docs/publish/#action-buttons)
es una característica que se lanzará en la aplicación de Android pronto. Permite a los usuarios agregar acciones a las notificaciones.
El soporte técnico limitado está disponible en la aplicación web.
**Funciones:**
* Notificación personalizada [botones de acción](https://ntfy.sh/docs/publish/#action-buttons) ([#134](https://github.com/binwiederhier/ntfy/issues/134),
gracias a [@mrherman](https://github.com/mrherman) para la presentación de informes)
* Se ha añadido la compilación ARMv6 ([#200](https://github.com/binwiederhier/ntfy/issues/200)gracias a [@jcrubioa](https://github.com/jcrubioa) para la presentación de informes)
* Compatibilidad con la internacionalización de aplicaciones 🇧🇬 🇩🇪 🇺🇸 🌎 web ([#189](https://github.com/binwiederhier/ntfy/issues/189))
**Bugs:**
* Aplicación web: correcciones de cadenas de idioma inglés, descripciones adicionales para la configuración ([#203](https://github.com/binwiederhier/ntfy/issues/203)gracias a [@StoyanDimitrov](https://github.com/StoyanDimitrov))
* Aplicación web: Mostrar mensaje de error snackbar cuando se produce un error al enviar una notificación de prueba ([#205](https://github.com/binwiederhier/ntfy/issues/205)gracias a [@cmeis](https://github.com/cmeis))
* Aplicación web: validación básica de URL en la administración de usuarios ([#204](https://github.com/binwiederhier/ntfy/issues/204)gracias a [@cmeis](https://github.com/cmeis))
* No permitir acciones GET/HEAD "http" con el cuerpo ([#221](https://github.com/binwiederhier/ntfy/issues/221)gracias a
[@cmeis](https://github.com/cmeis) para la presentación de informes)
**Traducciones (aplicación web):**
* Búlgaro (gracias a [@StoyanDimitrov](https://github.com/StoyanDimitrov))
* Alemán (gracias a [@cmeis](https://github.com/cmeis))
* Indonesio (gracias a [@linerly](https://hosted.weblate.org/user/linerly/))
* Japonés (gracias a [@shak](https://hosted.weblate.org/user/shak/))
* Bokmål noruego (gracias a [@comradekingu](https://github.com/comradekingu))
* Ruso (gracias a [@flamey](https://hosted.weblate.org/user/flamey/) y [@ilya.mikheev.coder](https://hosted.weblate.org/user/ilya.mikheev.coder/))
* Español (gracias a [@rogeliodh](https://github.com/rogeliodh))
* Turco (gracias a [@ersen](https://ersen.moe/))
**Integraciones:**
[Informar](https://github.com/caronc/apprise) el soporte se lanzó completamente en [v0.9.8.2](https://github.com/caronc/apprise/releases/tag/v0.9.8.2)
de Apprise. Gracias a [@particledecay](https://github.com/particledecay) y [@caronc](https://github.com/caronc) por su fantástico trabajo.
Puede probarlo usted mismo de esta manera (uso detallado en el [Wiki de Apprise](https://github.com/caronc/apprise/wiki/Notify_ntfy)):
pip3 install apprise
apprise -b "Hi there" ntfys://mytopic
## ntfy Aplicación android v1.11.0
Lanzamiento 7 Abr 2022
**Funciones:**
* Descargar archivos adjuntos a la carpeta de caché ([#181](https://github.com/binwiederhier/ntfy/issues/181))
* Elimine regularmente los archivos adjuntos de las notificaciones eliminadas ([#142](https://github.com/binwiederhier/ntfy/issues/142))
* Traducciones a diferentes idiomas ([#188](https://github.com/binwiederhier/ntfy/issues/188)gracias a
[@StoyanDimitrov](https://github.com/StoyanDimitrov) para iniciar cosas)
**Bugs:**
* IllegalStateException: Error al generar un archivo único ([#177](https://github.com/binwiederhier/ntfy/issues/177)gracias a [@Fallenbagel](https://github.com/Fallenbagel) para la presentación de informes)
* SQLiteConstraintException: Bloqueo durante el registro UP ([#185](https://github.com/binwiederhier/ntfy/issues/185))
* Actualizar la pantalla de preferencias después de la importación de la configuración (# 183, gracias a [@cmeis](https://github.com/cmeis) para la presentación de informes)
* Agregue cadenas de prioridad a las cadenas.xml para que sea traducible (# 192, gracias a [@StoyanDimitrov](https://github.com/StoyanDimitrov))
**Traducciones:**
* Mejoras en el idioma inglés (gracias a [@comradekingu](https://github.com/comradekingu))
* Búlgaro (gracias a [@StoyanDimitrov](https://github.com/StoyanDimitrov))
* Chino/Simplificado (gracias a [@poi](https://hosted.weblate.org/user/poi) y [@PeterCxy](https://hosted.weblate.org/user/PeterCxy))
* Holandés (*incompleto*gracias a [@diony](https://hosted.weblate.org/user/diony))
* Francés (gracias a [@Kusoneko](https://kusoneko.moe/) y [@mlcsthor](https://hosted.weblate.org/user/mlcsthor/))
* Alemán (gracias a [@cmeis](https://github.com/cmeis))
* Italiano (gracias a [@theTranslator](https://hosted.weblate.org/user/theTranslator/))
* Indonesio (gracias a [@linerly](https://hosted.weblate.org/user/linerly/))
* Bokmål noruego (*incompleto*gracias a [@comradekingu](https://github.com/comradekingu))
* Portugués/Brasil (gracias a [ML:](https://hosted.weblate.org/user/LW/))
* Español (gracias a [@rogeliodh](https://github.com/rogeliodh))
* Turco (gracias a [@ersen](https://ersen.moe/))
**Gracias:**
* Muchas gracias a [@cmeis](https://github.com/cmeis), [@Fallenbagel](https://github.com/Fallenbagel), [@Joeharrison94](https://github.com/Joeharrison94),
y [@rogeliodh](https://github.com/rogeliodh) para obtener información sobre la nueva lógica de datos adjuntos y para probar la versión
## Servidor ntfy v1.20.0
Lanzamiento 6 Abr 2022
**Funciones:**:
* Se ha añadido la barra de mensajes y el cuadro de diálogo de publicación ([#196](https://github.com/binwiederhier/ntfy/issues/196))
**Bugs:**
* Añadido `EXPOSE 80/tcp` a Dockerfile para admitir la detección automática en [Traefik](https://traefik.io/) ([#195](https://github.com/binwiederhier/ntfy/issues/195)gracias a [@s-h-a-r-d](https://github.com/s-h-a-r-d))
**Documentación:**
* Se ha agregado un ejemplo de docker-compose a [instrucciones de instalación](install.md#docker) ([#194](https://github.com/binwiederhier/ntfy/pull/194)gracias a [@s-h-a-r-d](https://github.com/s-h-a-r-d))
**Integraciones:**
* [Informar](https://github.com/caronc/apprise) ha añadido la integración en ntfy ([#99](https://github.com/binwiederhier/ntfy/issues/99), [apprise#524](https://github.com/caronc/apprise/pull/524),
gracias a [@particledecay](https://github.com/particledecay) y [@caronc](https://github.com/caronc) por su fantástico trabajo)
## Servidor ntfy v1.19.0
Lanzamiento 30 Mar 2022
**Bugs:**
* No empaquetar binario con `upx` para armv7/arm64 debido a `illegal instruction` errores ([#191](https://github.com/binwiederhier/ntfy/issues/191)gracias a [@iexos](https://github.com/iexos))
* No permitir comas en el nombre del tema en la publicación a través del punto de conexión GET (sin ticket)
* Agregue "Access-Control-Allow-Origin: \*" para los archivos adjuntos (sin ticket, gracias a @FrameXX)
* Hacer que la poda se ejecute de nuevo en la aplicación web ([#186](https://github.com/binwiederhier/ntfy/issues/186))
* Se han añadido parámetros que faltan `delay` y `email` Para publicar como cuerpo JSON (sin vale)
**Documentación:**
* Mejorado [publicación de correo electrónico](config.md#e-mail-publishing) documentación
## Servidor ntfy v1.18.1
Lanzamiento 21 Mar 2022\
*Esta versión no incluye características ni correcciones de errores. Es simplemente una actualización de la documentación.*
**Documentación:**
* Revisión de [documentación para desarrolladores](https://ntfy.sh/docs/develop/)
* Ejemplos de PowerShell para [publicar documentación](https://ntfy.sh/docs/publish/) ([#138](https://github.com/binwiederhier/ntfy/issues/138)gracias a [@Joeharrison94](https://github.com/Joeharrison94))
* Ejemplos adicionales para [NodeRED, Gatus, Sonarr, Radarr, ...](https://ntfy.sh/docs/examples/) (gracias a [@nickexyz](https://github.com/nickexyz))
* Correcciones en las instrucciones del desarrollador (gracias a [@Fallenbagel](https://github.com/Fallenbagel) para la presentación de informes)
## ntfy Aplicación android v1.10.0
Lanzamiento 21 Mar 2022
**Funciones:**
* Compatibilidad con la especificación UnifiedPush 2.0 (mensajes bytes, [#130](https://github.com/binwiederhier/ntfy/issues/130))
* Configuración de exportación/importación y suscripciones ([#115](https://github.com/binwiederhier/ntfy/issues/115)gracias [@cmeis](https://github.com/cmeis) para la presentación de informes)
* Abra el enlace "Click" al tocar la notificación ([#110](https://github.com/binwiederhier/ntfy/issues/110)gracias [@cmeis](https://github.com/cmeis) para la presentación de informes)
* Banner de obsolescencia de flujo JSON ([#164](https://github.com/binwiederhier/ntfy/issues/164))
**Correcciones:**
* Mostrar horas específicas de la configuración regional, con formato AM/PM o 24h ([#140](https://github.com/binwiederhier/ntfy/issues/140)gracias [@hl2guide](https://github.com/hl2guide) para la presentación de informes)
## Servidor ntfy v1.18.0
Lanzamiento 16 Mar 2022
**Funciones:**
* [Publicar mensajes como JSON](https://ntfy.sh/docs/publish/#publish-as-json) ([#133](https://github.com/binwiederhier/ntfy/issues/133),
gracias [@cmeis](https://github.com/cmeis) por informar, gracias a [@Joeharrison94](https://github.com/Joeharrison94) y
[@Fallenbagel](https://github.com/Fallenbagel) para pruebas)
**Correcciones:**
* rpm: no sobrescriba Server.yaml en la actualización del paquete ([#166](https://github.com/binwiederhier/ntfy/issues/166)gracias [@waclaw66](https://github.com/waclaw66) para la presentación de informes)
* Error tipográfico en [ntfy.sh/announcements](https://ntfy.sh/announcements) tema ([#170](https://github.com/binwiederhier/ntfy/pull/170)gracias a [@sandebert](https://github.com/sandebert))
* Correcciones de URL de imagen Léame ([#156](https://github.com/binwiederhier/ntfy/pull/156)gracias a [@ChaseCares](https://github.com/ChaseCares))
**Obsolescencias:**
* Se ha eliminado la capacidad de ejecutar el servidor como `ntfy` (a diferencia de `ntfy serve`) según [Desaprobación](deprecations.md)
## Servidor ntfy v1.17.1
Lanzamiento 12 Mar 2022
**Correcciones:**
* Reemplazar `crypto.subtle` con `hashCode` a errores con Brave/FF-Windows (#157, gracias por informar @arminus)
## Servidor ntfy v1.17.0
Lanzamiento 11 Mar 2022
**Características y correcciones de errores:**
* Reemplazar [aplicación web](https://ntfy.sh/app) con una aplicación web basada en React/MUI del siglo XXI (#111)
* Interfaz de usuario web rota con autenticación (# 132, gracias por informar @arminus)
* Enviar recursos web estáticos como `Content-Encoding: gzip`, es decir, documentos y aplicación web (sin ticket)
* Agregar soporte para autenticación a través de `?auth=...` parámetro de consulta, utilizado por WebSocket en la aplicación web (sin vale)
## Servidor ntfy v1.16.0
Lanzamiento 27 Feb 2022
**Características y correcciones de errores:**
* Agregar [Compatibilidad con autenticación](https://ntfy.sh/docs/subscribe/cli/#authentication) por suscribirse a CLI (#147/#148, gracias @lrabane)
* Agregar soporte para [?desde=<id>](https://ntfy.sh/docs/subscribe/api/#fetch-cached-messages) (#151, gracias por informar @nachotp)
**Documentación:**
* Agregar [ejemplos de watchtower/shoutrr](https://ntfy.sh/docs/examples/#watchtower-notifications-shoutrrr) (#150, gracias @rogeliodh)
* Agregar [Notas](https://ntfy.sh/docs/releases/)
**Notas técnicas:**
* A partir de esta versión, los IDENTIFICADORES de mensajes tendrán una longitud de 12 caracteres (en lugar de 10 caracteres). Esto es para poder
distinguirlos de las marcas de tiempo de Unix para #151.
## ntfy Aplicación para Android v1.9.1
Lanzamiento 16 Feb 2022
**Funciones:**
* Función Compartir en el tema (#131, gracias u/emptymatrix por informar)
* Capacidad para elegir un servidor predeterminado (# 127, gracias a @poblabs para informes y pruebas)
* Eliminar automáticamente las notificaciones (#71, gracias @arjan-s por los informes)
* Tema oscuro: Mejoras en el estilo y el contraste (#119, gracias @kzshantonu por informar)
**Correcciones:**
* No intente descargar archivos adjuntos si ya han caducado (#135)
* Se ha corregido el bloqueo en AddFragment como se ve por seguimiento de pila en Play Console (sin ticket)
**Otras gracias:**
* Gracias a @rogeliodh, @cmeis y @poblabs por las pruebas
## Servidor ntfy v1.15.0
Lanzamiento 14 Feb 2022
**Características y correcciones de errores:**
* Comprimir binarios con `upx` (#137)
* Agregar `visitor-request-limit-exempt-hosts` para eximir a los anfitriones amigables de los límites de tarifas (#144)
* Límite de solicitudes predeterminadas dobles por segundo de 1 por 10s a 1 por 5s (sin ticket)
* Convertir `\n` a nueva línea para `X-Message` encabezado como función de preparación para compartir (consulte #136)
* Reduzca el costo de bcrypt a 10 para que el tiempo de autenticación sea más razonable en servidores lentos (sin ticket)
* Actualización de documentos para incluir [temas de prueba pública](https://ntfy.sh/docs/publish/#public-topics) (sin billete)
## Servidor ntfy v1.14.1
Lanzamiento 9 Feb 2022
**Correcciones:**
* Arreglar la compilación de ARMv8 Docker (# 113, gracias a @djmaze)
* No hay otros cambios significativos
## ntfy Aplicación android v1.8.1
Lanzamiento 6 Feb 2022
**Funciones:**
* Apoyo [autenticación / control de acceso](https://ntfy.sh/docs/config/#access-control) (#19, gracias a @cmeis, @drsprite/@poblabs,
@gedw99, @karmanyaahm, @Mek101, @gc-ss, @julianfoad, @nmoseman, Jakob, PeterCxy, Techlosopher)
* Exportar/cargar registro ahora permite registros censurados/sin censura (sin ticket)
* Se ha eliminado el bloqueo de activación (excepto para el envío de notificaciones, sin ticket)
* Desliza el dedo para eliminar notificaciones (#117)
**Correcciones:**
* Solucionar problemas de descarga en SDK 29 "Movimiento no permitido" (#116, gracias Jakob)
* Solución para bloqueos de Android 12 (# 124, gracias @eskilop)
* Corregir el error de lógica de reintento de WebSocket con varios servidores (sin ticket)
* Corregir la carrera en la lógica de actualización que conduce a conexiones duplicadas (sin ticket)
* Solucione el problema de desplazamiento en el cuadro de diálogo suscribirse al tema (# 131, gracias @arminus)
* Corregir el color del campo de texto de la URL base en modo oscuro y el tamaño con fuentes grandes (sin ticket)
* Corregir el color de la barra de acción en modo oscuro (hacer negro, sin ticket)
**Notas:**
* Trabajo fundamental para la configuración por suscripción
## Servidor ntfy v1.14.0
Lanzamiento 3 Feb 2022
**Funciones**:
* Lado del servidor para [autenticación y autorización](https://ntfy.sh/docs/config/#access-control) (#19, gracias por probar @cmeis, y por los aportes de @gedw99, @karmanyaahm, @Mek101, @gc-ss, @julianfoad, @nmoseman, Jakob, PeterCxy, Techlosopher)
* Apoyo `NTFY_TOPIC` variable env en `ntfy publish` (#103)
**Correcciones**:
* Los mensajes binarios unifiedPush no deben convertirse en archivos adjuntos (parte 1, #101)
**Docs**:
* Aclaración sobre los archivos adjuntos (#118, gracias @xnumad)
## ntfy Aplicación para Android v1.7.1
Lanzamiento 21 Ene 2022
**Nuevas características:**
* Mejoras en la batería: wakelock deshabilitado de forma predeterminada (#76)
* Modo oscuro: permite cambiar la apariencia de la aplicación (#102)
* Registros de informes: Copiar/exportar registros para ayudar a solucionar problemas (#94)
* WebSockets (experimental): Use WebSockets para suscribirse a temas (#96, #100, #97)
* Mostrar banner de optimización de la batería (#105)
**Correcciones:**
* Soporte (parcial) para mensajes binarios de UnifiedPush (#101)
**Notas:**
* El wakelock en primer plano ahora está deshabilitado de forma predeterminada
* El reiniciador de servicio ahora está programado cada 3h en lugar de cada 6h
## Servidor ntfy v1.13.0
Lanzamiento 16 Ene 2022
**Funciones:**
* [Websockets](https://ntfy.sh/docs/subscribe/api/#websockets) Extremo
* Escuchar en el socket Unix, consulte [opción de configuración](https://ntfy.sh/docs/config/#config-options) `listen-unix`
## ntfy Aplicación android v1.6.0
Lanzamiento 14 Ene 2022
**Nuevas características:**
* Archivos adjuntos: Enviar archivos al teléfono (#25, #15)
* Acción de clic: Agregar una URL de acción de clic a las notificaciones (#85)
* Optimización de la batería: permite deshabilitar el bloqueo de activación persistente (# 76, gracias @MatMaul)
* Reconocer el certificado de CA de usuario importado para servidores autohospedados (#87, gracias @keith24)
* Elimine las menciones de "entrega instantánea" de F-Droid para que sea menos confuso (sin boleto)
**Correcciones:**
* La suscripción "silenciada hasta" no siempre fue respetada (#90)
* Corregir dos rastros de pila reportados por los signos vitales de Play Console (sin ticket)
* Truncar mensajes FCM >4.000 bytes, prefiere mensajes instantáneos (#84)
## Servidor ntfy v1.12.1
Lanzamiento 14 Ene 2022
**Correcciones:**
* Solucionar el problema de seguridad con el pico de datos adjuntos (#93)
## Servidor ntfy v1.12.0
Lanzamiento 13 Ene 2022
**Funciones:**
* [Accesorios](https://ntfy.sh/docs/publish/#attachments) (#25, #15)
* [Haga clic en la acción](https://ntfy.sh/docs/publish/#click-action) (#85)
* Aumentar la prioridad de FCM para mensajes de prioridad alta/máxima (#70)
**Correcciones:**
* Haga que el script postinst funcione correctamente para sistemas basados en rpm (# 83, gracias @cmeis)
* Truncar mensajes FCM de más de 4000 bytes (#84)
* Arreglar `listen-https` puerto (sin billete)
## ntfy Aplicación android v1.5.2
Lanzamiento 3 Ene 2022
**Nuevas características:**
* Permitir el uso de ntfy como distribuidor de UnifiedPush (#9)
* Soporte para mensajes más largos de hasta 4096 bytes (#77)
* Prioridad mínima: mostrar notificaciones solo si la prioridad X o superior (#79)
* Permitir la desactivación de difusiones en la configuración global (#80)
**Correcciones:**
* Permitir extras int/long para SEND_MESSAGE intención (#57)
* Varias correcciones de mejora de la batería (# 76)
## Servidor ntfy v1.11.2
Lanzamiento 1 Ene 2022
**Características y correcciones de errores:**
* Aumentar el límite de mensajes a 4096 bytes (4k) #77
* Documentos para [UnifiedPush](https://unifiedpush.org) #9
* Aumentar el intervalo keepalive a 55s #76
* Aumenta la vida útil de Firebase a 3 horas #76
## Servidor ntfy v1.10.0
Lanzamiento 28 Dic 2021
**Características y correcciones de errores:**
* [Publicar mensajes por correo electrónico](ntfy.sh/docs/publish/#e-mail-publishing) #66
* Trabajo del lado del servidor para admitir [unifiedpush.org](https://unifiedpush.org) #64
* Arreglando el error de Santa #65
## Versiones anteriores
Para versiones anteriores, echa un vistazo a las páginas de versiones de GitHub para el [Servidor ntfy](https://github.com/binwiederhier/ntfy/releases)
y el [Aplicación ntfy para Android](https://github.com/binwiederhier/ntfy-android/releases).

423
docs/subscribe/api-es.md Normal file
View file

@ -0,0 +1,423 @@
# Suscríbete a través de API
Puede crear y suscribirse a un tema en el [interfaz de usuario web](web.md), a través del [aplicación de teléfono](phone.md), a través del [CLI ntfy](cli.md),
o en su propia aplicación o script suscribiéndose a la API. Esta página describe cómo suscribirse a través de api. También es posible que desee
Consulte la página que describe cómo [publicar mensajes](../publish.md).
Puede consumir la API de suscripción como un **[flujo HTTP simple (JSON, SSE o raw)](#http-stream)**o
**[a través de WebSockets](#websockets)**. Ambos son increíblemente simples de usar.
## Flujo HTTP
La API basada en secuencias HTTP se basa en una simple solicitud GET con una respuesta HTTP de transmisión, es decir, **abre una solicitud GET y
La conexión permanece abierta para siempre**, enviando mensajes a medida que entran. Hay tres puntos de enlace de API diferentes, que
sólo difieren en el formato de respuesta:
* [Flujo JSON](#subscribe-as-json-stream): `<topic>/json` devuelve una secuencia JSON, con un objeto de mensaje JSON por línea
* [Flujo de ESS](#subscribe-as-sse-stream): `<topic>/sse` devuelve mensajes como [Eventos enviados por el servidor (SSE)](https://en.wikipedia.org/wiki/Server-sent_events)cuál
se puede utilizar con [Fuente de eventos](https://developer.mozilla.org/en-US/docs/Web/API/EventSource)
* [Flujo raw](#subscribe-as-raw-stream): `<topic>/raw` devuelve mensajes como texto sin formato, con una línea por mensaje
### Suscríbete como transmisión JSON
A continuación se muestran algunos ejemplos de cómo consumir el extremo JSON (`<topic>/json`). Para casi todos los idiomas, **este es el
forma recomendada de suscribirse a un tema**. La excepción notable es JavaScript, para el cual el
[Flujo SSE/EventSource](#subscribe-as-sse-stream) es mucho más fácil trabajar con él.
\=== "Línea de comandos (curl)"
` $ curl -s ntfy.sh/disk-alerts/json
{"id":"SLiKI64DOt","time":1635528757,"event":"open","topic":"mytopic"}
{"id":"hwQ2YpKdmg","time":1635528741,"event":"message","topic":"mytopic","message":"Disk full"}
{"id":"DGUDShMCsc","time":1635528787,"event":"keepalive","topic":"mytopic"}
...
`
\=== "ntfy CLI"
` $ ntfy subcribe disk-alerts
{"id":"hwQ2YpKdmg","time":1635528741,"event":"message","topic":"mytopic","message":"Disk full"}
...
`
\=== "HTTP"
''' http
GET /disk-alerts/json HTTP/1.1
Anfitrión: ntfy.sh
HTTP/1.1 200 OK
Content-Type: application/x-ndjson; charset=utf-8
Transfer-Encoding: chunked
{"id":"SLiKI64DOt","time":1635528757,"event":"open","topic":"mytopic"}
{"id":"hwQ2YpKdmg","time":1635528741,"event":"message","topic":"mytopic","message":"Disk full"}
{"id":"DGUDShMCsc","time":1635528787,"event":"keepalive","topic":"mytopic"}
...
```
\=== "Go"
` go
resp, err := http.Get("https://ntfy.sh/disk-alerts/json")
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
scanner := bufio.NewScanner(resp.Body)
for scanner.Scan() {
println(scanner.Text())
}
`
\=== "Python"
` python
resp = requests.get("https://ntfy.sh/disk-alerts/json", stream=True)
for line in resp.iter_lines():
if line:
print(line)
`
\=== "PHP"
` php-inline
$fp = fopen('https://ntfy.sh/disk-alerts/json', 'r');
if (!$fp) die('cannot open stream');
while (!feof($fp)) {
echo fgets($fp, 2048);
flush();
}
fclose($fp);
`
### Suscríbete como SSE stream
Usando [Fuente de eventos](https://developer.mozilla.org/en-US/docs/Web/API/EventSource) en JavaScript, puede consumir
notificaciones a través de un [Eventos enviados por el servidor (SSE)](https://en.wikipedia.org/wiki/Server-sent_events) corriente. Es increíblemente
fácil de usar. Así es como se ve. También es posible que desee consultar el [ejemplo completo en GitHub](https://github.com/binwiederhier/ntfy/tree/main/examples/web-example-eventsource).
\=== "Línea de comandos (curl)"
\`\`\`
$ curl -s ntfy.sh/mytopic/sse
evento: abierto
datos: {"id":"weSj9RtNkj","time":1635528898,"event":"open","topic":"mytopic"}
data: {"id":"p0M5y6gcCY","time":1635528909,"event":"message","topic":"mytopic","message":"Hi!"}
event: keepalive
data: {"id":"VNxNIg5fpt","time":1635528928,"event":"keepalive","topic":"test"}
...
```
\=== "HTTP"
''' http
OBTENER /mytopic/sse HTTP/1.1
Anfitrión: ntfy.sh
HTTP/1.1 200 OK
Content-Type: text/event-stream; charset=utf-8
Transfer-Encoding: chunked
event: open
data: {"id":"weSj9RtNkj","time":1635528898,"event":"open","topic":"mytopic"}
data: {"id":"p0M5y6gcCY","time":1635528909,"event":"message","topic":"mytopic","message":"Hi!"}
event: keepalive
data: {"id":"VNxNIg5fpt","time":1635528928,"event":"keepalive","topic":"test"}
...
```
\=== "JavaScript"
` javascript
const eventSource = new EventSource('https://ntfy.sh/mytopic/sse');
eventSource.onmessage = (e) => {
console.log(e.data);
};
`
### Suscríbete como flujo raw
El `/raw` El extremo generará una línea por mensaje, y **sólo incluirá el cuerpo del mensaje**. Es útil para extremadamente
scripts simples, y no incluye todos los datos. Campos adicionales como [prioridad](../publish.md#message-priority),
[Etiquetas](../publish.md#tags--emojis--) o [título del mensaje](../publish.md#message-title) no se incluyen en este resultado
formato. Los mensajes de Keepalive se envían como líneas vacías.
\=== "Línea de comandos (curl)"
\`\`\`
$ curl -s ntfy.sh/disk-alerts/raw
Disk full
...
```
\=== "HTTP"
''' http
GET /disk-alerts/raw HTTP/1.1
Anfitrión: ntfy.sh
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Transfer-Encoding: chunked
Disk full
...
```
\=== "Go"
` go
resp, err := http.Get("https://ntfy.sh/disk-alerts/raw")
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
scanner := bufio.NewScanner(resp.Body)
for scanner.Scan() {
println(scanner.Text())
}
`
\=== "Python"
` python
resp = requests.get("https://ntfy.sh/disk-alerts/raw", stream=True)
for line in resp.iter_lines():
if line:
print(line)
`
\=== "PHP"
` php-inline
$fp = fopen('https://ntfy.sh/disk-alerts/raw', 'r');
if (!$fp) die('cannot open stream');
while (!feof($fp)) {
echo fgets($fp, 2048);
flush();
}
fclose($fp);
`
## WebSockets
También puede suscribirse a temas a través de [WebSockets](https://en.wikipedia.org/wiki/WebSocket), que también es ampliamente
soportado en muchos idiomas. En particular, webSockets son compatibles de forma nativa en JavaScript. En la línea de comandos,
Recomiendo [websocat](https://github.com/vi/websocat), una herramienta fantástica similar a `socat` o `curl`, pero específicamente
para WebSockets.
El extremo WebSockets está disponible en `<topic>/ws` y devuelve mensajes como objetos JSON similares a los
[Extremo de transmisión JSON](#subscribe-as-json-stream).
\=== "Línea de comandos (websocat)"
` $ websocat wss://ntfy.sh/mytopic/ws
{"id":"qRHUCCvjj8","time":1642307388,"event":"open","topic":"mytopic"}
{"id":"eOWoUBJ14x","time":1642307754,"event":"message","topic":"mytopic","message":"hi there"}
`
\=== "HTTP"
''' http
GET /disk-alerts/ws HTTP/1.1
Anfitrión: ntfy.sh
Actualización: websocket
Conexión: Actualización
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
...
```
\=== "Go"
` go
import "github.com/gorilla/websocket"
ws, _, _ := websocket.DefaultDialer.Dial("wss://ntfy.sh/mytopic/ws", nil)
messageType, data, err := ws.ReadMessage()
...
`
\=== "JavaScript"
` javascript
const socket = new WebSocket('wss://ntfy.sh/mytopic/ws');
socket.addEventListener('message', function (event) {
console.log(event.data);
});
`
## Funciones avanzadas
### Sondeo para mensajes
También puede sondear mensajes si no le gusta la conexión de larga data utilizando el `poll=1`
parámetro de consulta. La conexión finalizará después de que se hayan leído todos los mensajes disponibles. Este parámetro puede ser
combinado con `since=` (el valor predeterminado es `since=all`).
curl -s "ntfy.sh/mytopic/json?poll=1"
### Recuperar mensajes almacenados en caché
Los mensajes pueden almacenarse en caché durante un par de horas (consulte [almacenamiento en caché de mensajes](../config.md#message-cache)) para dar cuenta de la red
interrupciones de suscriptores. Si el servidor ha configurado el almacenamiento en caché de mensajes, puede volver a leer lo que se perdió mediante el uso de
el `since=` parámetro de consulta. Toma una duración (por ejemplo, `10m` o `30s`), una marca de tiempo Unix (por ejemplo, `1635528757`),
un ID de mensaje (por ejemplo, `nFS3knfcQ1xe`), o `all` (todos los mensajes almacenados en caché).
curl -s "ntfy.sh/mytopic/json?since=10m"
curl -s "ntfy.sh/mytopic/json?since=1645970742"
curl -s "ntfy.sh/mytopic/json?since=nFS3knfcQ1xe"
### Recuperar mensajes programados
Mensajes que son [programado para ser entregado](../publish.md#scheduled-delivery) en una fecha posterior no suelen ser
devuelto al suscribirse a través de la API, lo que tiene sentido, porque después de todo, los mensajes técnicamente no han sido
entregado todavía. Para devolver también los mensajes programados de la API, puede utilizar el botón `scheduled=1` (alias: `sched=1`)
(tiene más sentido con el parámetro `poll=1` parámetro):
curl -s "ntfy.sh/mytopic/json?poll=1&sched=1"
### Filtrar mensajes
Puede filtrar qué mensajes se devuelven en función de los campos de mensajes conocidos `id`, `message`, `title`, `priority` y
`tags`. Este es un ejemplo que solo devuelve mensajes de prioridad alta o urgente que contienen las dos etiquetas
"zfs-error" y "error". Tenga en cuenta que el `priority` el filtro es un QUI lógico y el `tags` el filtro es un AND lógico.
$ curl "ntfy.sh/alerts/json?priority=high&tags=zfs-error"
{"id":"0TIkJpBcxR","time":1640122627,"event":"open","topic":"alerts"}
{"id":"X3Uzz9O1sM","time":1640122674,"event":"message","topic":"alerts","priority":4,
"tags":["error", "zfs-error"], "message":"ZFS pool corruption detected"}
Filtros disponibles (todos sin distinción de mayúsculas y minúsculas):
| | de variables de filtro Alias | Ejemplo | Descripción |
|-----------------|---------------------------|-----------------------------------------------|-------------------------------------------------------------------------|
| `id` | `X-ID` | `ntfy.sh/mytopic/json?poll=1&id=pbkiz8SD7ZxG` | Solo devuelve mensajes que coincidan con este ID de mensaje exacto |
| `message` | `X-Message`, `m` | `ntfy.sh/mytopic/json?message=lalala` | Solo devuelve mensajes que coincidan con esta cadena de mensaje exacta |
| `title` | `X-Title`, `t` | `ntfy.sh/mytopic/json?title=some+title` | Solo devuelve mensajes que coincidan con esta cadena de título exacta |
| `priority` | `X-Priority`, `prio`, `p` | `ntfy.sh/mytopic/json?p=high,urgent` | Solo devuelve mensajes que coinciden *cualquier prioridad enumerada* | (separados por comas)
| `tags` | `X-Tags`, `tag`, `ta` | `ntfy.sh/mytopic?/jsontags=error,alert` | Solo devuelve mensajes que coinciden *todas las etiquetas enumeradas* | (separados por comas)
### Suscríbete a varios temas
Es posible suscribirse a varios temas en una llamada HTTP proporcionando una lista de temas separados por comas
en la URL. Esto le permite reducir el número de conexiones que debe mantener:
$ curl -s ntfy.sh/mytopic1,mytopic2/json
{"id":"0OkXIryH3H","time":1637182619,"event":"open","topic":"mytopic1,mytopic2,mytopic3"}
{"id":"dzJJm7BCWs","time":1637182634,"event":"message","topic":"mytopic1","message":"for topic 1"}
{"id":"Cm02DsxUHb","time":1637182643,"event":"message","topic":"mytopic2","message":"for topic 2"}
### Autenticación
Dependiendo de si el servidor está configurado para admitir [control de acceso](../config.md#access-control), algunos temas
puede estar protegido contra lectura/escritura para que solo los usuarios con las credenciales correctas puedan suscribirse o publicar en ellos.
Para publicar/suscribirse a temas protegidos, puede utilizar [Autenticación básica](https://en.wikipedia.org/wiki/Basic_access_authentication)
con un nombre de usuario/contraseña válido. Para su servidor autohospedado, **Asegúrese de usar HTTPS para evitar escuchas** y exponer
su contraseña.
curl -u phil:mypass -s "https://ntfy.example.com/mytopic/json"
## Formato de mensaje JSON
Tanto el [`/json` Extremo](#subscribe-as-json-stream) y el [`/sse` Extremo](#subscribe-as-sse-stream) devolver un JSON
formato del mensaje. Es muy sencillo:
**Mensaje**:
| | de campo | requerido Tipo | Ejemplo | Descripción |
|--------------|----------|---------------------------------------------------|-------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------|
| `id` | ✔️ | *cuerda* | `hwQ2YpKdmg` | Identificador de mensaje elegido al azar |
| `time` | ✔️ | *número* | `1635528741` | Hora de la fecha del mensaje, como | de la marca de tiempo de Unix\
| `event` | ✔️ | `open`, `keepalive`, `message`o `poll_request` | `message` | Tipo de mensaje, normalmente solo te interesaría `message` |
| `topic` | ✔️ | *cuerda* | `topic1,topic2` | Lista separada por comas de los temas con los que está asociado el mensaje; sólo uno para todos `message` eventos, pero puede ser una lista en `open` | de eventos
| `message` | - | *cuerda* | `Some message` | Cuerpo del mensaje; siempre presente en `message` | de eventos
| `title` | - | *cuerda* | `Some title` | Mensaje [título](../publish.md#message-title); Si no, establezca los valores predeterminados en `ntfy.sh/<topic>` |
| `tags` | - | *matriz de cadenas* | `["tag1","tag2"]` | Lista de [Etiquetas](../publish.md#tags-emojis) que pueden o no asignarse a emojis |
| `priority` | - | *1, 2, 3, 4 o 5* | `4` | Mensaje [prioridad](../publish.md#message-priority) con 1=min, 3=default y 5=max |
| `click` | - | *URL* | `https://example.com` | Sitio web abierto cuando se notifica [Clic](../publish.md#click-action) |
| `actions` | - | *Matriz JSON* | *ver [botones de acciones](../publish.md#action-buttons)* | [Botones de acción](../publish.md#action-buttons) que se puede mostrar en el | de notificación
| `attachment` | - | *Objeto JSON* | *ver más abajo* | Detalles sobre un archivo adjunto (nombre, URL, tamaño, ...) |
**Archivo adjunto** (parte del mensaje, véase [Accesorios](../publish.md#attachments) para más detalles):
| | de campo | requerido Tipo | Ejemplo | Descripción |
|-----------|----------|-------------|--------------------------------|-----------------------------------------------------------------------------------------------------------|
| `name` | ✔️ | *cuerda* | `attachment.jpg` | Nombre del archivo adjunto, se puede anular con `X-Filename`ver [Accesorios](../publish.md#attachments) |
| `url` | ✔️ | *URL* | `https://example.com/file.jpg` | Dirección URL del | adjunto\
| `type` | -️ | *tipo mime* | `image/jpeg` | Tipo mime de los datos adjuntos, solo definido si los datos adjuntos se cargaron en el servidor ntfy |
| `size` | -️ | *número* | `33848` | Tamaño de los datos adjuntos en bytes, solo definido si los datos adjuntos se cargaron en el servidor ntfy |
| `expires` | -️ | *número* | `1635528741` | Fecha de caducidad de los datos adjuntos como marca de tiempo de Unix, solo definida si los datos adjuntos se cargaron en el servidor ntfy |
A continuación se muestra un ejemplo para cada tipo de mensaje:
\=== "Mensaje de notificación"
` json
{
"id": "sPs71M8A2T",
"time": 1643935928,
"event": "message",
"topic": "mytopic",
"priority": 5,
"tags": [
"warning",
"skull"
],
"click": "https://homecam.mynet.lan/incident/1234",
"attachment": {
"name": "camera.jpg",
"type": "image/png",
"size": 33848,
"expires": 1643946728,
"url": "https://ntfy.sh/file/sPs71M8A2T.png"
},
"title": "Unauthorized access detected",
"message": "Movement detected in the yard. You better go check"
}
`
\=== "Mensaje de notificación (mínimo)"
` json
{
"id": "wze9zgqK41",
"time": 1638542110,
"event": "message",
"topic": "phil_alerts",
"message": "Remote access to phils-laptop detected. Act right away."
}
`
\=== "Mensaje abierto"
` json
{
"id": "2pgIAaGrQ8",
"time": 1638542215,
"event": "open",
"topic": "phil_alerts"
}
`
\=== "Mensaje Keepalive"
` json
{
"id": "371sevb0pD",
"time": 1638542275,
"event": "keepalive",
"topic": "phil_alerts"
}
`
\=== "Mensaje de solicitud de sondeo"
` json
{
"id": "371sevb0pD",
"time": 1638542275,
"event": "poll_request",
"topic": "phil_alerts"
}
`
## Lista de todos los parámetros
La siguiente es una lista de todos los parámetros que se pueden pasar **al suscribirse a un mensaje**. Los nombres de los parámetros son **no distingue entre mayúsculas y minúsculas**,
y se puede pasar como **Encabezados HTTP** o **parámetros de consulta en la dirección URL**. Se enumeran en la tabla en su forma canónica.
| | de parámetros Alias (sin distinción entre mayúsculas y minúsculas) | Descripción |
|-------------|----------------------------|---------------------------------------------------------------------------------|
| `poll` | `X-Poll`, `po` | Devolver mensajes almacenados en caché y cerrar | de conexión
| `since` | `X-Since`, `si` | Devolver mensajes almacenados en caché desde la marca de tiempo, la duración o el ID del mensaje |
| `scheduled` | `X-Scheduled`, `sched` | Incluir mensajes programados/retrasados en la lista de |
| `id` | `X-ID` | Filtro: solo devuelve mensajes que coincidan con este ID de mensaje exacto |
| `message` | `X-Message`, `m` | Filtro: solo devuelve mensajes que coincidan con esta cadena de mensaje exacta |
| `title` | `X-Title`, `t` | Filtro: solo devuelve mensajes que coincidan con esta cadena de título exacta |
| `priority` | `X-Priority`, `prio`, `p` | Filtro: solo devuelve mensajes que coinciden *cualquier prioridad enumerada* | (separados por comas)
| `tags` | `X-Tags`, `tag`, `ta` | Filtro: solo devuelve mensajes que coinciden *todas las etiquetas enumeradas* | (separados por comas)

291
docs/subscribe/cli-es.md Normal file
View file

@ -0,0 +1,291 @@
# Suscríbete a través de ntfy CLI
Además de suscribirse a través del [interfaz de usuario web](web.md)el [aplicación de teléfono](phone.md), o el [API](api.md), puedes suscribirte
a los temas a través de la CLI de ntfy. La CLI está incluida en la misma `ntfy` binario que se puede utilizar para [autohospedar un servidor](../install.md).
!!! información
El **La CLI de Ntfy no es necesaria para enviar o recibir mensajes**. En su lugar, puede [enviar mensajes con curl](../publish.md),
e incluso usarlo para [suscribirse a temas](api.md). Puede ser un poco más conveniente usar la CLI ntfy que escribir
tu propio guión. Todo depende del caso de uso. 😀
## Instalar + configurar
Para instalar la CLI de ntfy, simplemente **Siga los pasos descritos en el cuadro de diálogo [página de instalación](../install.md)**. El servidor ntfy y
los clientes son el mismo binario, por lo que todo es muy conveniente. Después de la instalación, puede (opcionalmente) configurar el cliente
creando `~/.config/ntfy/client.yml` (para el usuario no root), o `/etc/ntfy/client.yml` (para el usuario root). Tú
puede encontrar un [configuración de esqueleto](https://github.com/binwiederhier/ntfy/blob/main/client/client.yml) en GitHub.
Si solo quieres usar [ntfy.sh](https://ntfy.sh), no tienes que cambiar nada. Si usted **autohospede su propio servidor**,
Es posible que desee modificar el cuadro de diálogo `default-host` opción:
```yaml
# Base URL used to expand short topic names in the "ntfy publish" and "ntfy subscribe" commands.
# If you self-host a ntfy server, you'll likely want to change this.
#
default-host: https://ntfy.myhost.com
```
## Publicar mensajes
Puede enviar mensajes con la CLI de ntfy mediante el `ntfy publish` (o cualquiera de sus alias) `pub`, `send` o
`trigger`). Hay muchos ejemplos en la página sobre [publicar mensajes](../publish.md), pero aquí hay algunos
rápidos:
\=== "Envío simple"
` ntfy publish mytopic This is a message
ntfy publish mytopic "This is a message"
ntfy pub mytopic "This is a message"
`
\=== "Enviar con título, prioridad y etiquetas"
` ntfy publish \ --title="Thing sold on eBay" \ --priority=high \ --tags=partying_face \
mytopic \
"Somebody just bought the thing that you sell"
`
\=== "Enviar a las 8:30am"
` ntfy pub --at=8:30am delayed_topic Laterzz
`
\=== "Triggering a webhook"
` ntfy trigger mywebhook
ntfy pub mywebhook
`
### Adjuntar un archivo local
Puede cargar y adjuntar fácilmente un archivo local a una notificación:
$ ntfy pub --file README.md mytopic | jq .
{
"id": "meIlClVLABJQ",
"time": 1655825460,
"event": "message",
"topic": "mytopic",
"message": "You received a file: README.md",
"attachment": {
"name": "README.md",
"type": "text/plain; charset=utf-8",
"size": 2892,
"expires": 1655836260,
"url": "https://ntfy.sh/file/meIlClVLABJQ.txt"
}
}
### Espere a PID/comando
Si tiene un comando de ejecución prolongada y desea **Publicar una notificación cuando se complete el comando**,
puede envolverlo con `ntfy publish --wait-cmd` (alias: `--cmd`, `--done`). O, si olvidó envolverlo, y el
El comando ya se está ejecutando, puede esperar a que se complete el proceso con `ntfy publish --wait-pid` (alias: `--pid`).
Ejecute un comando y espere a que se complete (aquí: `rsync ...`):
$ ntfy pub --wait-cmd mytopic rsync -av ./ root@example.com:/backups/ | jq .
{
"id": "Re0rWXZQM8WB",
"time": 1655825624,
"event": "message",
"topic": "mytopic",
"message": "Command succeeded after 56.553s: rsync -av ./ root@example.com:/backups/"
}
O bien, si ya inició el proceso de ejecución prolongada y desea esperarlo con su ID de proceso (PID), puede hacer lo siguiente:
\=== "Usando un PID directamente"
` $ ntfy pub --wait-pid 8458 mytopic | jq .
{
"id": "orM6hJKNYkWb",
"time": 1655825827,
"event": "message",
"topic": "mytopic",
"message": "Process with PID 8458 exited after 2.003s"
}
`
\=== "Usando un `pidof`"
` $ ntfy pub --wait-pid $(pidof rsync) mytopic | jq .
{
"id": "orM6hJKNYkWb",
"time": 1655825827,
"event": "message",
"topic": "mytopic",
"message": "Process with PID 8458 exited after 2.003s"
}
`
## Suscríbete a los temas
Puede suscribirse a temas usando `ntfy subscribe`. Dependiendo de cómo se llame, este comando
imprimirá o ejecutará un comando para cada mensaje que llegue. Hay algunas maneras diferentes
en el que se puede ejecutar el comando:
### Transmitir mensajes como JSON
ntfy subscribe TOPIC
Si ejecuta el comando de esta manera, imprime la representación JSON de cada mensaje entrante. Esto es útil
cuando tiene un comando que desea transmitir y leer mensajes JSON entrantes. A menos que `--poll` se pasa, este comando
permanece abierto para siempre.
$ ntfy sub mytopic
{"id":"nZ8PjH5oox","time":1639971913,"event":"message","topic":"mytopic","message":"hi there"}
{"id":"sekSLWTujn","time":1639972063,"event":"message","topic":"mytopic",priority:5,"message":"Oh no!"}
...
<figure>
<video controls muted autoplay loop width="650" src="../../static/img/cli-subscribe-video-1.mp4"></video>
<figcaption>Subscribe in JSON mode</figcaption>
</figure>
### Ejecutar comando para cada mensaje
ntfy subscribe TOPIC COMMAND
Si lo ejecuta de esta manera, se ejecuta un COMANDO para cada mensaje entrante. Desplácese hacia abajo para ver una lista de disponibles
variables de entorno. Aquí hay algunos ejemplos:
ntfy sub mytopic 'notify-send "$m"'
ntfy sub topic1 /my/script.sh
ntfy sub topic1 'echo "Message $m was received. Its title was $t and it had priority $p'
<figure>
<video controls muted autoplay loop width="650" src="../../static/img/cli-subscribe-video-2.webm"></video>
<figcaption>Execute command on incoming messages</figcaption>
</figure>
Los campos de mensaje se pasan al comando como variables de entorno y se pueden utilizar en scripts. Tenga en cuenta que desde
Estas son variables de entorno, normalmente no tiene que preocuparse por citar demasiado, siempre y cuando las incluya
entre comillas dobles, debería estar bien:
| | variable Alias | Descripción |
|------------------|----------------------------|----------------------------------------|
| `$NTFY_ID` | `$id` | Identificador de mensaje único |
| `$NTFY_TIME` | `$time` | Marca de tiempo Unix del | de entrega de mensajes
| `$NTFY_TOPIC` | `$topic` | Nombre del tema |
| `$NTFY_MESSAGE` | `$message`, `$m` | | del cuerpo del mensaje
| `$NTFY_TITLE` | `$title`, `$t` | Título del mensaje |
| `$NTFY_PRIORITY` | `$priority`, `$prio`, `$p` | Prioridad del mensaje (1=min, 5=max) |
| `$NTFY_TAGS` | `$tags`, `$tag`, `$ta` | Etiquetas de mensaje (lista separada por comas) |
| `$NTFY_RAW` | `$raw` | | de mensajes JSON sin procesar
### Suscríbete a varios temas
ntfy subscribe --from-config
Para suscribirse a varios temas a la vez y ejecutar diferentes comandos para cada uno, puede usar `ntfy subscribe --from-config`,
que leerá el `subscribe` config desde el archivo de configuración. Por favor, echa un vistazo también a la [Servicio systemd ntfy-client](#using-the-systemd-service).
Aquí hay un archivo de configuración de ejemplo que se suscribe a tres temas diferentes, ejecutando un comando diferente para cada uno de ellos:
\=== "~/.config/ntfy/client.yml (Linux)"
` yaml
subscribe: - topic: echo-this
command: 'echo "Message received: $message"' - topic: alerts
command: notify-send -i /usr/share/ntfy/logo.png "Important" "$m"
if:
priority: high,urgent - topic: calc
command: 'gnome-calculator 2>/dev/null &' - topic: print-temp
command: |
echo "You can easily run inline scripts, too."
temp="$(sensors | awk '/Pack/ { print substr($4,2,2) }')"
if [ $temp -gt 80 ]; then
echo "Warning: CPU temperature is $temp. Too high."
else
echo "CPU temperature is $temp. That's alright."
fi
`
\=== "~/Library/Application Support/ntfy/client.yml (macOS)"
` yaml
subscribe: - topic: echo-this
command: 'echo "Message received: $message"' - topic: alerts
command: osascript -e "display notification \"$message\""
if:
priority: high,urgent - topic: calc
command: open -a Calculator
`
\=== "%AppData%\ntfy\client.yml (Windows)"
` yaml
subscribe: - topic: echo-this
command: 'echo Message received: %message%' - topic: alerts
command: |
notifu /m "%NTFY_MESSAGE%"
exit 0
if:
priority: high,urgent - topic: calc
command: calc
`
En este ejemplo, cuando `ntfy subscribe --from-config` se ejecuta:
* Mensajes a `echo-this` simplemente hace eco a la salida estándar
* Mensajes a `alerts` Mostrar como notificación de escritorio para mensajes de alta prioridad mediante [notificar-enviar](https://manpages.ubuntu.com/manpages/focal/man1/notify-send.1.html) (Linux),
[notifu](https://www.paralint.com/projects/notifu/) (Ventanas) o `osascript` (macOS)
* Mensajes a `calc` abra la calculadora 😀 (*porque, ¿por qué no?*)
* Mensajes a `print-temp` Ejecute un script en línea e imprima la temperatura de la CPU (solo versión de Linux)
Espero que esto muestre cuán poderoso es este comando. Aquí hay un breve video que demuestra el ejemplo anterior:
<figure>
<video controls muted autoplay loop width="650" src="../../static/img/cli-subscribe-video-3.webm"></video>
<figcaption>Execute all the things</figcaption>
</figure>
### Uso del servicio systemd
Puede utilizar el `ntfy-client` servicio systemd (consulte [ntfy-client.service](https://github.com/binwiederhier/ntfy/blob/main/client/ntfy-client.service))
para suscribirse a varios temas como en el ejemplo anterior. El servicio se instala automáticamente (pero no se inicia)
si instala el paquete deb/rpm. Para configurarlo, simplemente edite `/etc/ntfy/client.yml` y ejecutar `sudo systemctl restart ntfy-client`.
!!! información
El `ntfy-client.service` se ejecuta como usuario `ntfy`, lo que significa que se aplican restricciones de permisos típicas de Linux. Vea a continuación
para saber cómo solucionarlo.
Si el servicio se ejecuta en el equipo de escritorio personal, es posible que desee invalidar el usuario/grupo de servicio (`User=` y `Group=`), y
ajustar el `DISPLAY` y `DBUS_SESSION_BUS_ADDRESS` variables de entorno. Esto le permitirá ejecutar comandos en su sesión X
como usuario principal de la máquina.
Puede invalidar manualmente estas entradas de servicio systemd con `sudo systemctl edit ntfy-client`, y agregue esto
(suponiendo que su usuario es `phil`). No te olvides de correr `sudo systemctl daemon-reload` y `sudo systemctl restart ntfy-client`
después de editar el archivo de servicio:
\=== "/etc/systemd/system/ntfy-client.service.d/override.conf"
` [Service]
User=phil
Group=phil
Environment="DISPLAY=:0" "DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus"
`
O bien, puede ejecutar el siguiente script que crea esta configuración de anulación por usted:
sudo sh -c 'cat > /etc/systemd/system/ntfy-client.service.d/override.conf' <<EOF
[Service]
User=$USER
Group=$USER
Environment="DISPLAY=:0" "DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/$(id -u)/bus"
EOF
sudo systemctl daemon-reload
sudo systemctl restart ntfy-client
### Autenticación
Dependiendo de si el servidor está configurado para admitir [control de acceso](../config.md#access-control), algunos temas
puede estar protegido contra lectura/escritura para que solo los usuarios con las credenciales correctas puedan suscribirse o publicar en ellos.
Para publicar/suscribirse a temas protegidos, puede utilizar [Autenticación básica](https://en.wikipedia.org/wiki/Basic_access_authentication)
con un nombre de usuario/contraseña válido. Para su servidor autohospedado, **Asegúrese de usar HTTPS para evitar escuchas** y exponer
su contraseña.
Puede agregar su nombre de usuario y contraseña al archivo de configuración:
\=== "~/.config/ntfy/client.yml"
`yaml - topic: secret
command: 'notify-send "$m"'
user: phill
password: mypass
`
O con el `ntfy subscibe` mandar:
ntfy subscribe \
-u phil:mypass \
ntfy.example.com/mysecrets

240
docs/subscribe/phone-es.md Normal file
View file

@ -0,0 +1,240 @@
# Suscríbete desde tu teléfono
Puedes usar el ntfy [Aplicación android](https://play.google.com/store/apps/details?id=io.heckel.ntfy) o [Aplicación iOS](https://apps.apple.com/us/app/ntfy/id1625396347)
para recibir notificaciones directamente en tu teléfono. Al igual que el servidor, esta aplicación también es de código abierto y el código está disponible.
en GitHub ([Androide](https://github.com/binwiederhier/ntfy-android), [Ios](https://github.com/binwiederhier/ntfy-ios)). Siéntase libre de
contribuir, o [construye el tuyo propio](../develop.md).
<a href="https://play.google.com/store/apps/details?id=io.heckel.ntfy"><img src="../../static/img/badge-googleplay.png"></a> <a href="https://f-droid.org/en/packages/io.heckel.ntfy/"><img src="../../static/img/badge-fdroid.png"></a> <a href="https://apps.apple.com/us/app/ntfy/id1625396347"><img src="../../static/img/badge-appstore.png"></a>
Puede obtener la aplicación de Android desde ambos [Google Play](https://play.google.com/store/apps/details?id=io.heckel.ntfy) y
De [F-Droide](https://f-droid.org/en/packages/io.heckel.ntfy/). Ambos son en gran medida idénticos, con la única excepción de que
el sabor F-Droid no utiliza Firebase. La aplicación iOS se puede descargar desde el [Tienda de aplicaciones](https://apps.apple.com/us/app/ntfy/id1625396347).
## Visión general
Una imagen vale más que mil palabras. Aquí hay algunas capturas de pantalla que muestran cómo se ve la aplicación. Todo es bonito
Sencillo. Puede agregar temas y tan pronto como los agregue, puede [publicar mensajes](../publish.md) a ellos.
<div id="android-screenshots" class="screenshots">
<a href="../../static/img/android-screenshot-main.png"><img src="../../static/img/android-screenshot-main.png"/></a>
<a href="../../static/img/android-screenshot-detail.png"><img src="../../static/img/android-screenshot-detail.png"/></a>
<a href="../../static/img/android-screenshot-pause.png"><img src="../../static/img/android-screenshot-pause.png"/></a>
<a href="../../static/img/android-screenshot-add.png"><img src="../../static/img/android-screenshot-add.png"/></a>
<a href="../../static/img/android-screenshot-add-instant.png"><img src="../../static/img/android-screenshot-add-instant.png"/></a>
<a href="../../static/img/android-screenshot-add-other.png"><img src="../../static/img/android-screenshot-add-other.png"/></a>
</div>
Si esas capturas de pantalla aún no son suficientes, aquí hay un video:
<figure>
<video controls muted autoplay loop width="650" src="../../static/img/android-video-overview.mp4"></video>
<figcaption>Sending push notifications to your Android phone</figcaption>
</figure>
## Prioridad del mensaje
*Soportado en:* :material-android: :material-manzana:
Cuando [publicar mensajes](../publish.md#message-priority) a un tema, puedes **definir una prioridad**. Esta prioridad define
con qué urgencia Android le notificará sobre la notificación y si hacen un sonido y / o vibran.
De forma predeterminada, los mensajes con prioridad predeterminada o superior (> = 3) vibrarán y emitirán un sonido. Mensajes con alto o urgente
la prioridad (> = 4) también se mostrará como pop-over, así:
<figure markdown>
![priority notification](../static/img/priority-notification.png){ width=500 }
<figcaption>High and urgent notifications show as pop-over</figcaption>
</figure>
Puede cambiar esta configuración en Android presionando prolongadamente la aplicación y tocando "Notificaciones" o desde "Configuración"
en "Configuración del canal". Hay un canal de notificación para cada prioridad:
<figure markdown>
![notification settings](../static/img/android-screenshot-notification-settings.png){ width=500 }
<figcaption>Per-priority channels</figcaption>
</figure>
Por canal de notificación, puede configurar un **sonido específico del canal**, si se debe **Anular el DND de No molestar (DND)**
configuración y otras configuraciones como popover o punto de notificación:
<figure markdown>
![channel details](../static/img/android-screenshot-notification-details.jpg){ width=500 }
<figcaption>Per-priority sound/vibration settings</figcaption>
</figure>
## Entrega instantánea
*Soportado en:* :material-androide:
La entrega instantánea le permite recibir mensajes en su teléfono al instante, **incluso cuando el teléfono está en modo dormitado**, es decir,
cuando la pantalla se apaga y la dejas en el escritorio por un tiempo. Esto se logra con un servicio en primer plano, que
verás como una notificación permanente que se ve así:
<figure markdown>
![foreground service](../static/img/foreground-service.png){ width=500 }
<figcaption>Instant delivery foreground notification</figcaption>
</figure>
Android no le permite descartar esta notificación, a menos que desactive el canal de notificación en la configuración.
Para hacerlo, mantenga presionada la notificación en primer plano (captura de pantalla anterior) y navegue hasta la configuración. A continuación, cambie el botón
"Servicio de suscripción" desactivado:
<figure markdown>
![foreground service](../static/img/notification-settings.png){ width=500 }
<figcaption>Turning off the persistent instant delivery notification</figcaption>
</figure>
**Limitaciones sin entrega instantánea**: Sin entrega instantánea, **Los mensajes pueden llegar con un retraso significativo**
(a veces muchos minutos, o incluso horas después). Si alguna vez has cogido el teléfono y
de repente tuve 10 mensajes que se enviaron mucho antes de que supieras de lo que estoy hablando.
La razón de esto es [Mensajería en la nube de Firebase (FCM)](https://firebase.google.com/docs/cloud-messaging). FCM es el
*solamente* Google aprobó la forma de enviar mensajes push a dispositivos Android, y es lo que casi todas las aplicaciones usan para entregar push
notificaciones. Firebase es en general bastante malo para entregar mensajes a tiempo, pero en Android, la mayoría de las aplicaciones están atascadas con él.
La aplicación ntfy para Android usa Firebase solo para el host principal `ntfy.sh`, y solo en el sabor Google Play de la aplicación.
No usará Firebase para ningún servidor autohospedado, y no en absoluto en el sabor F-Droid.
## Compartir en el tema
*Soportado en:* :material-androide:
Puede compartir archivos en un tema utilizando la función "Compartir" de Android. Esto funciona en casi cualquier aplicación que admita compartir archivos
o texto, y es útil para enviarse enlaces, archivos u otras cosas. La función recuerda algunos de los últimos temas
compartiste contenido y los enumeras en la parte inferior.
La característica es bastante autoexplicativa, y una imagen dice más de mil palabras. Así que aquí hay dos imágenes:
<div id="share-to-topic-screenshots" class="screenshots">
<a href="../../static/img/android-screenshot-share-1.jpg"><img src="../../static/img/android-screenshot-share-1.jpg"/></a>
<a href="../../static/img/android-screenshot-share-2.jpg"><img src="../../static/img/android-screenshot-share-2.jpg"/></a>
</div>
## ntfy:// enlaces
*Soportado en:* :material-androide:
La aplicación ntfy para Android admite enlaces profundos directamente a los temas. Esto es útil cuando se integra con [aplicaciones de automatización](#automation-apps)
como [Macrodroid](https://play.google.com/store/apps/details?id=com.arlosoft.macrodroid) o [Tasker](https://play.google.com/store/apps/details?id=net.dinglisch.android.taskerm),
o simplemente para vincular directamente a un tema desde un sitio web móvil.
!!! información
La vinculación profunda de Android de enlaces http / https es muy frágil y limitada, por lo que algo como `https://<host>/<topic>/subscribe` es
**no es posible**, y en su lugar `ntfy://` hay que utilizar enlaces. Más detalles en [número #20](https://github.com/binwiederhier/ntfy/issues/20).
**Formatos de enlace compatibles:**
| Formato de enlace | Ejemplo | Descripción |
|-------------------------------------------------------------------------------|-------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| <span style="white-space: nowrap">`ntfy://<host>/<topic>`</span> | `ntfy://ntfy.sh/mytopic` | Abre directamente la vista de detalles de la aplicación de Android para el tema y el servidor dados. Se suscribe al tema si aún no está suscrito. Esto es equivalente a la vista web `https://ntfy.sh/mytopic` (¡HTTPS!) |
| <span style="white-space: nowrap">`ntfy://<host>/<topic>?secure=false`</span> | `ntfy://example.com/mytopic?secure=false` | Igual que el anterior, excepto que esto usará HTTP en lugar de HTTPS como URL del tema. Esto es equivalente a la vista web `http://example.com/mytopic` (¡HTTP!) |
## Integraciones
### UnifiedPush
*Soportado en:* :material-androide:
[UnifiedPush](https://unifiedpush.org) es un estándar para recibir notificaciones push sin usar la propiedad de Google
[Mensajería en la nube de Firebase (FCM)](https://firebase.google.com/docs/cloud-messaging) servicio. Pone notificaciones push
en el control del usuario. ntfy puede actuar como un **Distribuidor de UnifiedPush**, reenviar mensajes a aplicaciones que lo admitan.
Para utilizar ntfy como distribuidor, simplemente selecciónelo en uno de los [aplicaciones compatibles](https://unifiedpush.org/users/apps/).
Eso es todo. Es una instalación 😀 de un solo paso. Si lo desea, puede seleccionar el suyo propio [servidor ntfy autohospedado](../install.md)
para manejar mensajes. Aquí hay un ejemplo con [FluffyChat](https://fluffychat.im/):
<div id="unifiedpush-screenshots" class="screenshots">
<a href="../../static/img/android-screenshot-unifiedpush-fluffychat.jpg"><img src="../../static/img/android-screenshot-unifiedpush-fluffychat.jpg"/></a>
<a href="../../static/img/android-screenshot-unifiedpush-subscription.jpg"><img src="../../static/img/android-screenshot-unifiedpush-subscription.jpg"/></a>
<a href="../../static/img/android-screenshot-unifiedpush-settings.jpg"><img src="../../static/img/android-screenshot-unifiedpush-settings.jpg"/></a>
</div>
### Aplicaciones de automatización
*Soportado en:* :material-androide:
La aplicación ntfy para Android se integra muy bien con aplicaciones de automatización como [Macrodroid](https://play.google.com/store/apps/details?id=com.arlosoft.macrodroid)
o [Tasker](https://play.google.com/store/apps/details?id=net.dinglisch.android.taskerm). Usando las intenciones de Android, puedes
**reaccionar a los mensajes entrantes**, así como **enviar mensajes**.
#### Reaccionar a los mensajes entrantes
Para reaccionar a las notificaciones entrantes, debe registrarse en intents con el `io.heckel.ntfy.MESSAGE_RECEIVED` acción (véase
[código para más detalles](https://github.com/binwiederhier/ntfy-android/blob/main/app/src/main/java/io/heckel/ntfy/msg/BroadcastService.kt)).
Aquí hay un ejemplo usando [Macrodroid](https://play.google.com/store/apps/details?id=com.arlosoft.macrodroid)
y [Tasker](https://play.google.com/store/apps/details?id=net.dinglisch.android.taskerm), pero cualquier aplicación que pueda atrapar
se admiten transmisiones:
<div id="integration-screenshots-receive" class="screenshots">
<a href="../../static/img/android-screenshot-macrodroid-overview.png"><img src="../../static/img/android-screenshot-macrodroid-overview.png"/></a>
<a href="../../static/img/android-screenshot-macrodroid-trigger.png"><img src="../../static/img/android-screenshot-macrodroid-trigger.png"/></a>
<a href="../../static/img/android-screenshot-macrodroid-action.png"><img src="../../static/img/android-screenshot-macrodroid-action.png"/></a>
<a href="../../static/img/android-screenshot-tasker-profiles.png"><img src="../../static/img/android-screenshot-tasker-profiles.png"/></a>
<a href="../../static/img/android-screenshot-tasker-event-edit.png"><img src="../../static/img/android-screenshot-tasker-event-edit.png"/></a>
<a href="../../static/img/android-screenshot-tasker-task-edit.png"><img src="../../static/img/android-screenshot-tasker-task-edit.png"/></a>
<a href="../../static/img/android-screenshot-tasker-action-edit.png"><img src="../../static/img/android-screenshot-tasker-action-edit.png"/></a>
</div>
Para MacroDroid, asegúrese de escribir el nombre del paquete `io.heckel.ntfy`, de lo contrario, las intenciones pueden tragarse en silencio.
Si usas temas para impulsar la automatización, es probable que desees silenciar el tema en la aplicación ntfy. Esto evitará
ventanas emergentes de notificación:
<figure markdown>
![muted subscription](../static/img/android-screenshot-muted.png){ width=500 }
<figcaption>Muting notifications to prevent popups</figcaption>
</figure>
Aquí hay una lista de extras a los que puede acceder. Lo más probable es que desee filtrar por `topic` y reaccionar en `message`:
| Nombre adicional | Tipo | Ejemplo | Descripción |
|----------------------|------------------------------|------------------------------------------|------------------------------------------------------------------------------------|
| `id` | *Cuerda* | `bP8dMjO8ig` | Identificador de mensaje elegido al azar (probablemente no muy útil para la automatización de tareas) |
| `base_url` | *Cuerda* | `https://ntfy.sh` | URL raíz del servidor ntfy este mensaje proviene de |
| `topic` ❤️ | *Cuerda* | `mytopic` | Nombre del tema; **Es probable que desee filtrar por un tema específico** |
| `muted` | *Booleano* | `true` | Indica si la suscripción se silenció en la aplicación |
| `muted_str` | *Cadena (`true` o `false`)* | `true` | Igual que `muted`, pero como cadena `true` o `false` |
| `time` | *Int* | `1635528741` | Hora de la fecha del mensaje, como | de la marca de tiempo de Unix
| `title` | *Cuerda* | `Some title` | Mensaje [título](../publish.md#message-title); puede estar vacío si no está configurado |
| `message` ❤️ | *Cuerda* | `Some message` | Cuerpo del mensaje; **Esto es probablemente lo que te interesa** |
| `message_bytes` | *ByteArray* | `(binary data)` | Cuerpo del mensaje como | de datos binarios
| `encoding`️ | *Cuerda* | - | Codificación de mensajes (vacía o "base64") |
| `tags` | *Cuerda* | `tag1,tag2,..` | Lista separada por comas de [Etiquetas](../publish.md#tags-emojis) |
| `tags_map` | *Cuerda* | `0=tag1,1=tag2,..` | Mapa de etiquetas para facilitar el mapeo primero, segundo, ... | de etiquetas
| `priority` | *Int (entre 1-5)* | `4` | Mensaje [prioridad](../publish.md#message-priority) con 1=min, 3=default y 5=max |
| `click` | *Cuerda* | `https://google.com` | [Haga clic en la acción](../publish.md#click-action) URL, o vacía si no está establecida |
| `attachment_name` | *Cuerda* | `attachment.jpg` | Nombre de archivo del archivo adjunto; puede estar vacío si no está configurado |
| `attachment_type` | *Cuerda* | `image/jpeg` | Tipo mimo del accesorio; puede estar vacío si no está configurado |
| `attachment_size` | *Largo* | `9923111` | Tamaño en bytes del archivo adjunto; puede ser cero si no se establece |
| `attachment_expires` | *Largo* | `1655514244` | Fecha de caducidad como marca de tiempo Unix de la URL adjunta; puede ser cero si no se establece |
| `attachment_url` | *Cuerda* | `https://ntfy.sh/file/afUbjadfl7ErP.jpg` | URL del archivo adjunto; puede estar vacío si no está configurado |
#### Enviar mensajes mediante intenciones
Para enviar mensajes desde otras aplicaciones (como [Macrodroid](https://play.google.com/store/apps/details?id=com.arlosoft.macrodroid)
y [Tasker](https://play.google.com/store/apps/details?id=net.dinglisch.android.taskerm)), puede
transmitir una intención con el `io.heckel.ntfy.SEND_MESSAGE` acción. La aplicación ntfy para Android reenviará la intención como un HTTP
SOLICITUD POST a [publicar un mensaje](../publish.md). Esto es principalmente útil para aplicaciones que no admiten HTTP POST/PUT
(como MacroDroid). En Tasker, simplemente puede usar la acción "Solicitud HTTP", que es un poco más fácil y también funciona si
ntfy no está instalado.
Así es como se ve:
<div id="integration-screenshots-send" class="screenshots">
<a href="../../static/img/android-screenshot-macrodroid-send-macro.png"><img src="../../static/img/android-screenshot-macrodroid-send-macro.png"/></a>
<a href="../../static/img/android-screenshot-macrodroid-send-action.png"><img src="../../static/img/android-screenshot-macrodroid-send-action.png"/></a>
<a href="../../static/img/android-screenshot-tasker-profile-send.png"><img src="../../static/img/android-screenshot-tasker-profile-send.png"/></a>
<a href="../../static/img/android-screenshot-tasker-task-edit-post.png"><img src="../../static/img/android-screenshot-tasker-task-edit-post.png"/></a>
<a href="../../static/img/android-screenshot-tasker-action-http-post.png"><img src="../../static/img/android-screenshot-tasker-action-http-post.png"/></a>
</div>
Los siguientes extras de intención son compatibles cuando para la intención con el `io.heckel.ntfy.SEND_MESSAGE` acción:
| Nombre adicional | | requerido Tipo | Ejemplo | Descripción |
|--------------|----------|-------------------------------|-------------------|------------------------------------------------------------------------------------|
| `base_url` | - | *Cuerda* | `https://ntfy.sh` | La dirección URL raíz del servidor ntfy del que procede este mensaje, de forma predeterminada es `https://ntfy.sh` |
| `topic` ❤️ | ✔ | *Cuerda* | `mytopic` | Nombre del tema; **Debe establecer esto** |
| `title` | - | *Cuerda* | `Some title` | Mensaje [título](../publish.md#message-title); puede estar vacío si no está configurado |
| `message` ❤️ | ✔ | *Cuerda* | `Some message` | Cuerpo del mensaje; **Debe establecer esto** |
| `tags` | - | *Cuerda* | `tag1,tag2,..` | Lista separada por comas de [Etiquetas](../publish.md#tags-emojis) |
| `priority` | - | *String o Int (entre 1-5)* | `4` | Mensaje [prioridad](../publish.md#message-priority) con 1=min, 3=default y 5=max |

21
docs/subscribe/web-es.md Normal file
View file

@ -0,0 +1,21 @@
# Suscribirse desde la interfaz de usuario web
También puede usar la interfaz de usuario web para suscribirse a temas. Si lo hace, y mantiene el sitio web abierto, **notificaciones
aparece como notificaciones de escritorio**. Simplemente escriba el nombre del tema y haga clic en el botón *Subscribir* botón. El navegador
mantenga una conexión abierta y escuche las notificaciones entrantes.
Para obtener información sobre cómo enviar mensajes, consulte el [página de publicación](../publish.md).
<div id="web-screenshots" class="screenshots">
<a href="../../static/img/web-detail.png"><img src="../../static/img/web-detail.png"/></a>
<a href="../../static/img/web-notification.png"><img src="../../static/img/web-notification.png"/></a>
<a href="../../static/img/web-subscribe.png"><img src="../../static/img/web-subscribe.png"/></a>
</div>
Para seguir recibiendo notificaciones de escritorio de ntfy, debe mantener el sitio web abierto. Lo que hago, y lo que recomiendo encarecidamente,
es anclar la pestaña para que siempre esté abierta, pero algo fuera del camino:
<figure markdown>
![pinned](../static/img/web-pin.png){ width=500 }
<figcaption>Pin web app to move it out of the way</figcaption>
</figure>