All perguntas(server)

Tenho uma câmera IP que grava vídeos em uma estrutura de pastas como esta:

├── 2023
│   ├── 10
│   ├── 11
│   │   ├── cam_00_20240921153706.mp4
│   │   ├── cam_00_20240921153928.mp4
│   │   ├── cam_00_20240921164743.mp4
│   │   └── cam_00_20240921230558.mp4
│   └── 12
└── 2024
    ├── 08
    └── 09
        ├── 21
        │   ├── cam_00_20240921153706.mp4
        │   ├── cam_00_20240921153928.mp4
        │   ├── cam_00_20240921164743.mp4
        │   ├── cam_00_20240921230558.mp4
        │   └── cam_00_20240921230646.mp4
        └── 22
            ├── cam_00_20240922101839.mp4
            └── cam_00_20240922102150.mp4

Agora eu gostaria de apagar todos os arquivos com mais de 2 dias, e todas as pastas vazias. Para fazer isso, eu fiz

#delete files older than 2 days
find /recordings/????/??/?? -depth -type d -mtime +2 -exec rm -rf {} \;
#delete empty month dir
find /recordings/????/?? -depth -empty -type d -mtime +2 -exec rm -rf {} \;
#delete empty year dir
find /recordings/???? -depth -empty -type d -mtime +2 -exec rm -rf {} \;

Isso pode ser feito com uma frase de efeito? Ou de uma forma mais legal?

Tenho três pares em uma rede WireGuard:

• O Peer J está atrás de um firewall corporativo padrão bloqueando todos os UDP de saída,
• O Peer S é um servidor com IP estático e
• Peer P é meu smartphone.

   No UDP out;
  +-----------+  (Static IP)
  | Peer J ---|--- Peer S ------ Peer P
  +-----------+         [Regular wg]
So, UDP over TCP

Quero conectar o peer P ao peer J (P ssh em J) via WireGuard, onde J e S são conectados por UDP sobre TCP (usando wangyu-/udp2raw ), enquanto S e P têm uma conexão WireGuard UDP padrão.

Aqui está minha tentativa até agora:

Par J

[Interface]
# PublicKey = E8K...
PrivateKey = ...
Address = 10.0.0.6/24
MTU = 1342
PreUp = /usr/bin/udp2raw -c -l 127.0.0.1:50001 -r <S's internet IP>:443 -k "secret" -a >/var/log/udp2raw.log 2>&1 &
PostDown = killall udp2raw || true

# Peer S
[Peer]
PublicKey = Yf3...
AllowedIPs = 10.0.0.0/32
PersistentKeepalive = 120
Endpoint = 127.0.0.1:50001

Pares

[Interface]
# PublicKey = Yf3...
PrivateKey = ...
Address = 10.0.0.0/24
MTU = 1342
ListenPort = 80
PreUp = /usr/bin/udp2raw -s -r 127.0.0.1:80 -l <S's LAN IP>:443 -k "secret" -a >/var/log/udp2raw.log 2>&1 &
PreDown = killall udp2raw || true

# Peer J
[Peer]
PublicKey = E8K...
AllowedIPs = 10.0.0.6/32
PersistentKeepalive = 120

# Peer P
[Peer]
PublicKey = wlx...
AllowedIPs = 10.0.0.19/32

Par P

[Interface]
PublicKey = wlx...
Address = 10.0.0.19/32
MTU = 1342

# Peer S
[Peer]
PublicKey = Yf3...
AllowedIPs = 10.0.0.0/24
Endpoint = <S's internet IP>:80

Problema: O peer P não pode fazer ping no peer J. Mas o peer J pode fazer ping no peer S e vice-versa; e o peer S pode fazer ping no peer P e vice-versa. O traceroute de P para J é:

raceroute to 10.0.0.6 (10.0.0.6), 30 hops max, 60 byte packets
  1  ip-10-0-0-0.region.compute.internal (10.0.0.0)  54.950 ms  54.063 ms  53.245 ms
  2  * * *
  3  * * *

Então há algo errado com o roteamento em S, mas não consigo descobrir qual é exatamente o problema.

Acabei de configurar o stream pass through usando ssl_prereado nginx, mas não consigo descobrir como, usando esse método, proibir o acesso a servidores upstream específicos para determinados intervalos de IP. Isso host1não deve permitir 10.0.1.0/24, por exemplo, e host2não deve permitir10.0.44.0/24

Tenho um roteador virtualizado com endereço IP público atribuído a ele diretamente no proxmox. Quando envio uma solicitação para a porta 443 de uma rede diferente (de um navegador), o roteador encaminha corretamente a porta para meu contêiner NGINX em um IP privado.

Já que o roteador executou um NAT no pacote do IP público para um endereço local 10.0.0.0/8, como o NGINX sabe qual era o IP original do cliente? Ele relata meu IP público corretamente em access.log, mas todas as informações de IP que ele deveria estar vendo seriam o IP privado do roteador, não é?

Além disso, quando verifico os cabeçalhos na minha guia de rede no cliente, não há nenhum cabeçalho X-Forwarded-For, e também não há nenhum outro proxy reverso (que eu saiba) que adicionaria o cabeçalho, definitivamente nenhum com os certificados SSL corretos para fazer isso.

Obrigado

Tenho um cenário em que uso o OpenELB como um banco de dados de carga para anunciar o endereço MAC da minha interface e o endereço IP externo (192.168.41.71) no meu cluster Kubernetes.

Pelo que entendi, não preciso do endereço IP da interface, porque o mundo externo só precisa saber o endereço EIP e o endereço Mac da interface.

Minha pergunta é: como posso receber pacotes sem o endereço IP da interface e encaminhá-los para a tabela de roteamento local pelo IPVS?

Quando eu defino um endereço IP aleatoriamente, os pacotes podem ser recebidos e encaminhados normalmente. No entanto, se eu excluir o endereço IP da interface, não funciona.

0 Estou experimentando os serviços da AWS para construir meu projeto, um backend Java usando Docker para contêineres e Maven para dependências, e Angular 16 para meu front-end, agora tenho uma VPC com 6 sub-redes, duas delas são públicas. Tenho uma instância RDS com acesso público também e uma instância EC2 de nível gratuito em execução com conexão a essa instância RDS, ainda não testei essa conexão, então não tenho certeza se funciona. Estou tentando construir meu projeto dentro do EC2, um comando Docker Compose Up com vários serviços Java Maven onde dois deles têm uma dependência do meu repositório CodeArtifact, mas, não só não consegue acessar essa dependência, embora eu tenha o settings.xml configurado corretamente, o comando para obter o token do CodeArtifact termina com um tempo limite quando tento executá-lo dentro do EC2, mas funciona bem na minha máquina local. Meus Security Groups, aqueles que este EC2 está usando, têm permissão de saída para todos os protocolos em "0.0.0.0/0" e "::/0" e minhas políticas CodeArtifact estão permitindo tudo para meu usuário root e meu usuário dev, que estou usando agora. Estou fazendo algo errado? Vi aqui que é possível, mas talvez não mais? As sub-redes públicas têm a mesma configuração de ACL, tentei adicionar outra regra para permitir tráfego de saída e entrada, mas não funcionou!

Também estou adicionando as regras de entrada e saída aqui para ter certeza de que não estou esquecendo nenhuma configuração

Tentei criar uma função IAM, mas também não funcionou! Criei uma nova instância e tentei com e sem a função IAM, mesmo depois de anexar a função IAM, estou ficando sem tempo! Consegui tirar uma captura de tela com ambos antes e depois de anexar a função IAM

Usamos um Active Directory local para domínio e uma assinatura do Microsoft Office 365 para e-mails. E temos MIIS para sincronizá-los.

Notei que quando movo um usuário de uma UO para outra no AD local, o usuário perde a licença do Microsoft 365 e sua conta de e-mail para de funcionar.

Ao investigar e perguntar, encontrei alguns registros no cliente MIIS sobre os usuários movidos. Parece que o MIIS está configurado de alguma forma para excluir a conta da Microsoft quando um usuário é movido.

Alguém pode me orientar a corrigir esse erro fatal?

Meu objetivo é configurar uma VPN bidirecional site-to-site. Quero poder acessar o lado do servidor do lado do cliente, e o lado do cliente do lado do servidor.

Não estou fazendo nada avançado e tentei seguir as instruções no guia de conexão site-to-site do OpenVPN. Mas, acho que, como estou usando dois roteadores DD-WRT como meu servidor e VPNs de cliente, estou tendo um problema em corresponder o guia à minha situação.

Do lado do cliente, consigo conectar aos hosts de rede do lado do servidor. Do lado do servidor, não consigo conectar aos hosts do lado do cliente.

Mapa de rede:

Rede CG-NAT LAN 192.168.0.0/22 ​​Cliente OpenVPN em DD-WRT 192.168.0.2

Rede LAN regular 192.168.4.0/22 ​​Servidor OpenVPN em DD-WRT 192.168.4.2

Túnel: 10.10.28.1 <-> 10.10.28.2 (posso ver que está configurado corretamente nos logs)

Eu controlo ambos os lados, então estava tentando configurar as rotas para consertar o problema. Suspeito que as rotas (ou as configurações no servidor OpenVPN) estejam erradas.

Esta é a tabela de roteamento no lado do cliente OpenVPN:

Destination     Gateway         Genmask         Flags Metric Ref    Use Iface
default         192.168.0.1     0.0.0.0         UG    0      0        0 br0
10.10.28.0      *               255.255.255.0   U     0      0        0 tun1
127.0.0.0       *               255.0.0.0       U     0      0        0 lo
192.168.0.0     *               255.255.252.0   U     0      0        0 br0
192.168.4.0     10.10.28.1      255.255.252.0   UG    200    0        0 tun1

Posso fazer ping de qualquer lugar na rede do cliente para a rede 192.168.4.0:

# ping 192.168.4.222
PING 192.168.4.222 (192.168.4.222): 56 data bytes
64 bytes from 192.168.4.222: seq=0 ttl=63 time=42.244 ms
64 bytes from 192.168.4.222: seq=1 ttl=63 time=32.047 ms

Esta é a tabela de roteamento no host do servidor OpenVPN quando a abro pela primeira vez:

default via 192.168.4.1 dev br0
10.10.28.0/24 dev tun2 scope link  src 10.10.28.1
127.0.0.0/8 dev lo scope link
192.168.4.0/22 dev br0 scope link  src 192.168.4.2

Observações: Não consigo fazer ping da rede do servidor para a rede 192.168.0.0. NO ENTANTO, enquanto estiver logado no host do servidor OpenVPN (192.168.4.2), consigo fazer ping do outro lado do túnel (10.10.28.2)

# ping 10.10.28.2
PING 10.10.28.2 (10.10.28.2): 56 data bytes
64 bytes from 10.10.28.2: seq=0 ttl=64 time=40.287 ms
64 bytes from 10.10.28.2: seq=1 ttl=64 time=35.791 ms


# traceroute 192.168.0.1
traceroute to 192.168.0.1 (192.168.0.1), 30 hops max, 46 byte packets
 1  192.168.4.1 (192.168.4.1)  5.108 ms  4.927 ms  3.953 ms
 2  *  *

Então, meu primeiro palpite foi adicionar esta rota para corresponder à rota do Cliente para a sub-rede do Servidor:

route add -net 192.168.0.0 netmask 255.255.252.0 gw 10.10.28.2 metric 200 tun2

Isso criou uma entrada adicional:

192.168.0.0     10.10.28.2      255.255.252.0   UG    200    0        0 tun2

Isso fez alguma diferença, mas o traceroute ou os pings não retornam.

# traceroute 192.168.0.1
traceroute to 192.168.0.1 (192.168.0.1), 30 hops max, 46 byte packets
 1  *  *  *

Obviamente sou iniciante, então me diga se preciso de mais informações para me ajudar.

Agora que o Zstd está lentamente recebendo suporte nos navegadores, estou pensando se posso manter a compactação do Zstd e encaminhar os arquivos como estão com o ZFS.

Atualmente, até onde sei, o ZFS descompacta implicitamente os arquivos compactados Zstd antes que meu servidor web possa manipulá-los, e o servidor web precisa compactá-los novamente antes de enviá-los aos usuários.

Existe uma maneira de passar esses arquivos diretamente para o servidor web sem a compactação de ida e volta?

Provavelmente usarei nginx ou caddy para servir esses arquivos, mas estou interessado em saber se há uma maneira de acessar as versões compactadas dos arquivos em qualquer software executado no Linux, por exemplo, python, nodejs, ruby ​​ou php.

No meu roteador (ubuntu/NFTables) configurei duas WANs, uma de cada ISP diferente.

Na configuração atual, posso garantir que qualquer máquina nas sub-redes possa navegar usando o primeiro ou o segundo link, de acordo com a regra do NFTables.

Observe que não é uma interface LAN específica (qualquer máquina em qualquer interface LAN pode navegar em qualquer um dos dois links com IPs públicos de acordo com a regra em NFTables)

Isso está funcionando, ok.

O problema que estou enfrentando agora é que as máquinas nas sub-redes deveriam se ver e elas nem sequer estão fazendo ping umas nas outras.

Alguém sabe como posso consertar isso para que, além de manter a navegação na internet assim, eu consiga fazer com que as máquinas conectadas na LAN1, LAN2, LAN3 e LAN4 consigam se comunicar entre si?

Abaixo está a configuração do netplan:

network:
ethernets:
    wan1:
        addresses:
        - 111.31.111.2/28
        - 111.31.111.3/28
        - 111.31.111.4/28
        - 111.31.111.5/28
        - 111.31.111.6/28
        - 111.31.111.7/28
        - 111.31.111.8/28
        - 111.31.111.9/28
        - 111.31.111.10/28
        - 111.31.111.11/28
        - 111.31.111.12/28
        - 111.31.111.13/28
        - 111.31.111.14/28
        nameservers:
            addresses:
            - 8.8.8.8
            - 8.8.4.4
            search: []
        routes:
        - to: default
          via: 111.31.111.1
          metric: 100
        - to: default
          via: 111.31.111.1
          metric: 100
          table: 100
        routing-policy:
        - from: 192.168.10.0/24
          table: 100
        - from: 192.168.20.0/24
          table: 100
        - from: 192.168.30.0/24
          table: 100
        - from: 192.168.40.0/24
          table: 100
    wan2:
        addresses:
        - 222.63.222.10/29
        - 222.63.222.11/29
        - 222.63.222.12/29
        - 222.63.222.13/29
        - 222.63.222.14/29
        nameservers:
            addresses:
            - 8.8.8.8
            - 8.8.4.4
            search: []
        routes:
        - to: default
          via: 222.63.222.9
          metric: 200
        - to: default
          via: 222.63.222.9
          metric: 200
          table: 200
        routing-policy:
        - from: 192.168.10.0/24
          table: 200
        - from: 192.168.20.0/24
          table: 200
        - from: 192.168.30.0/24
          table: 200
        - from: 192.168.40.0/24
          table: 200
    lan1:
        addresses:
        - 192.168.10.1/24
    lan2:
        addresses:
        - 192.168.20.1/24
    lan3:
        addresses:
        - 192.168.30.1/24
    lan4:
        addresses:
        - 192.168.40.1/24
version: 2

Tabelas e regras a seguir:

userrouter1@router1:~$ ip route
default via 111.31.111.1 dev wan1 proto static metric 100 
default via 222.63.222.9 dev wan2 proto static metric 200 
192.168.10.0/24 dev lan1 proto kernel scope link src 192.168.10.1 
192.168.40.0/24 dev lan4 proto kernel scope link src 192.168.40.1 
111.31.111.0/28 dev wan1 proto kernel scope link src 111.31.111.2 
222.63.222.8/29 dev wan2 proto kernel scope link src 222.63.222.10

userrouter1@router1:~$ ip rule
0:  from all lookup local
32756:  from 192.168.30.0/24 lookup 200 proto static
32757:  from 192.168.40.0/24 lookup 200 proto static
32758:  from 192.168.20.0/24 lookup 200 proto static
32759:  from 192.168.10.0/24 lookup 200 proto static
32760:  from 192.168.30.0/24 lookup 100 proto static
32761:  from 192.168.10.0/24 lookup 100 proto static
32762:  from 192.168.40.0/24 lookup 100 proto static
32763:  from 192.168.20.0/24 lookup 100 proto static
32766:  from all lookup main
32767:  from all lookup default

userrouter1@router1:~$ ip route show table 100
default via 111.31.111.1 dev wan1 proto static metric 100 

userrouter1@router1:~$ ip route show table 200
default via 222.63.222.9 dev wan2 proto static metric 200 

userrouter1@router1:~$ ip rule show table 100
32760:  from 192.168.30.0/24 lookup 100 proto static
32761:  from 192.168.10.0/24 lookup 100 proto static
32762:  from 192.168.40.0/24 lookup 100 proto static
32763:  from 192.168.20.0/24 lookup 100 proto static

userrouter1@router1:~$ ip rule show table 200
32756:  from 192.168.30.0/24 lookup 200 proto static
32757:  from 192.168.40.0/24 lookup 200 proto static
32758:  from 192.168.20.0/24 lookup 200 proto static
32759:  from 192.168.10.0/24 lookup 200 proto static

No momento, se eu estiver na máquina 192.168.10.10 não consigo fazer PING em 192.168.20.10, nem vice-versa... Eu precisava resolver esse problema, mantendo a navegação para IPs externos assim.

Alguém pode me ajudar?