Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1 105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Je redoute un ralentissement de l'application qui tourne sur le serveur,
Bind 9.3.1, cad un timeout sur des requêtes lorsque le script tourne.
J'ai essaye 2 méthodes, mais la charge CPU ne se reduit pas, j'en cherche
donc une autre.
1 - Passer les fichiers dans une liste, ensuite utiliser la liste pour
compter.
@liste=("queries.log", "queries.log.0", "queries.log.1", "queries.log.2");
foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier: $!";
while (<FIC>) {
push (@liste_ip, <FIC>);
};
};
close (FIC);
Ca marchera pas: tu lis de FIC deux fois chaque tour. Aussi, il vaut
2 - Lire chaque fichier et traiter ligne à ligne.
my $today = time();
my $minus=$today - 3600;
my $need = strftime "%d-%b-%Y %H", localtime($minus);
@liste=("queries.log", "queries.log.0", "queries.log.1","queries.log.2");
Il vaut mieux donner les noms de fichier sur le ligne de commande.
foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier: $!";
while ($line = <FIC>) {
chomp ($line);
if ($line =~ /^($need)(.*) client (.*)#(.*) view (.*)$/)
Le problème ici est que le regex est calculé chaque fois, mais $need se
{
$total{$3} += 1;
}
};
};
close (FIC);
Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1 105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Je redoute un ralentissement de l'application qui tourne sur le serveur,
Bind 9.3.1, cad un timeout sur des requêtes lorsque le script tourne.
J'ai essaye 2 méthodes, mais la charge CPU ne se reduit pas, j'en cherche
donc une autre.
1 - Passer les fichiers dans une liste, ensuite utiliser la liste pour
compter.
@liste=("queries.log", "queries.log.0", "queries.log.1", "queries.log.2");
foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier: $!";
while (<FIC>) {
push (@liste_ip, <FIC>);
};
};
close (FIC);
Ca marchera pas: tu lis de FIC deux fois chaque tour. Aussi, il vaut
2 - Lire chaque fichier et traiter ligne à ligne.
my $today = time();
my $minus=$today - 3600;
my $need = strftime "%d-%b-%Y %H", localtime($minus);
@liste=("queries.log", "queries.log.0", "queries.log.1","queries.log.2");
Il vaut mieux donner les noms de fichier sur le ligne de commande.
foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier: $!";
while ($line = <FIC>) {
chomp ($line);
if ($line =~ /^($need)(.*) client (.*)#(.*) view (.*)$/)
Le problème ici est que le regex est calculé chaque fois, mais $need se
{
$total{$3} += 1;
}
};
};
close (FIC);
Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1 105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Je redoute un ralentissement de l'application qui tourne sur le serveur,
Bind 9.3.1, cad un timeout sur des requêtes lorsque le script tourne.
J'ai essaye 2 méthodes, mais la charge CPU ne se reduit pas, j'en cherche
donc une autre.
1 - Passer les fichiers dans une liste, ensuite utiliser la liste pour
compter.
@liste=("queries.log", "queries.log.0", "queries.log.1", "queries.log.2");
foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier: $!";
while (<FIC>) {
push (@liste_ip, <FIC>);
};
};
close (FIC);
Ca marchera pas: tu lis de FIC deux fois chaque tour. Aussi, il vaut
2 - Lire chaque fichier et traiter ligne à ligne.
my $today = time();
my $minus=$today - 3600;
my $need = strftime "%d-%b-%Y %H", localtime($minus);
@liste=("queries.log", "queries.log.0", "queries.log.1","queries.log.2");
Il vaut mieux donner les noms de fichier sur le ligne de commande.
foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier: $!";
while ($line = <FIC>) {
chomp ($line);
if ($line =~ /^($need)(.*) client (.*)#(.*) view (.*)$/)
Le problème ici est que le regex est calculé chaque fois, mais $need se
{
$total{$3} += 1;
}
};
};
close (FIC);
Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1 105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1 105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1 105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Le deuxième exemple est mieux.
Donc se sera la base pour la modification.
Il vaut mieux donner les noms de fichier sur le ligne de commande.
my @files = @ARGV;
Ok pour cette methode, elle est appliqué.
/^($need)(.*) client (.*)#(.*) view (.*)$/o
voir perldoc perlre pour les informations sur /o.
Cette option permet en effet de :
Benchmark::Timer
Je ne peux malheureusement pas installer de module sur mon serveur ... mais
J'espere que tu peux comprendre mon franglais :)
Oui oui parfaitement ; )))
Geo Kosto wrote:Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo
sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1
105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Je redoute un ralentissement de l'application qui tourne sur le serveur,
Bind 9.3.1, cad un timeout sur des requêtes lorsque le script tourne.
J'ai essaye 2 méthodes, mais la charge CPU ne se reduit pas, j'en
cherche
donc une autre.
1 - Passer les fichiers dans une liste, ensuite utiliser la liste pour
compter.
@liste=("queries.log", "queries.log.0", "queries.log.1",
"queries.log.2");
foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier:
$!";
while (<FIC>) {
push (@liste_ip, <FIC>);
};
};
close (FIC);
Ca marchera pas: tu lis de FIC deux fois chaque tour. Aussi, il vaut
mieux utiliser un hash, sinon on va chercher l'addresse DNS chaque fois
pour chaque ligne.
Le deuxième exemple est mieux.
2 - Lire chaque fichier et traiter ligne à ligne.
my $today = time();
my $minus=$today - 3600;
my $need = strftime "%d-%b-%Y %H", localtime($minus);
@liste=("queries.log", "queries.log.0",
"queries.log.1","queries.log.2");
Il vaut mieux donner les noms de fichier sur le ligne de commande.
my @files = @ARGV;foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier:
$!";
while ($line = <FIC>) {
chomp ($line);
if ($line =~ /^($need)(.*) client (.*)#(.*) view (.*)$/)
Le problème ici est que le regex est calculé chaque fois, mais $need se
change jamais. Mettre /o après le regex.
/^($need)(.*) client (.*)#(.*) view (.*)$/o
voir perldoc perlre pour les informations sur /o.
Aussi, utiliser
Benchmark::Timer
afin d'observer bien la difference en performance.{
$total{$3} += 1;
}
};
};
close (FIC);
J'espere que tu peux comprendre mon franglais :)
Mark
Le deuxième exemple est mieux.
Donc se sera la base pour la modification.
Il vaut mieux donner les noms de fichier sur le ligne de commande.
my @files = @ARGV;
Ok pour cette methode, elle est appliqué.
/^($need)(.*) client (.*)#(.*) view (.*)$/o
voir perldoc perlre pour les informations sur /o.
Cette option permet en effet de :
Benchmark::Timer
Je ne peux malheureusement pas installer de module sur mon serveur ... mais
J'espere que tu peux comprendre mon franglais :)
Oui oui parfaitement ; )))
Geo Kosto wrote:
Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo
sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1
105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Je redoute un ralentissement de l'application qui tourne sur le serveur,
Bind 9.3.1, cad un timeout sur des requêtes lorsque le script tourne.
J'ai essaye 2 méthodes, mais la charge CPU ne se reduit pas, j'en
cherche
donc une autre.
1 - Passer les fichiers dans une liste, ensuite utiliser la liste pour
compter.
@liste=("queries.log", "queries.log.0", "queries.log.1",
"queries.log.2");
foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier:
$!";
while (<FIC>) {
push (@liste_ip, <FIC>);
};
};
close (FIC);
Ca marchera pas: tu lis de FIC deux fois chaque tour. Aussi, il vaut
mieux utiliser un hash, sinon on va chercher l'addresse DNS chaque fois
pour chaque ligne.
Le deuxième exemple est mieux.
2 - Lire chaque fichier et traiter ligne à ligne.
my $today = time();
my $minus=$today - 3600;
my $need = strftime "%d-%b-%Y %H", localtime($minus);
@liste=("queries.log", "queries.log.0",
"queries.log.1","queries.log.2");
Il vaut mieux donner les noms de fichier sur le ligne de commande.
my @files = @ARGV;
foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier:
$!";
while ($line = <FIC>) {
chomp ($line);
if ($line =~ /^($need)(.*) client (.*)#(.*) view (.*)$/)
Le problème ici est que le regex est calculé chaque fois, mais $need se
change jamais. Mettre /o après le regex.
/^($need)(.*) client (.*)#(.*) view (.*)$/o
voir perldoc perlre pour les informations sur /o.
Aussi, utiliser
Benchmark::Timer
afin d'observer bien la difference en performance.
{
$total{$3} += 1;
}
};
};
close (FIC);
J'espere que tu peux comprendre mon franglais :)
Mark
Le deuxième exemple est mieux.
Donc se sera la base pour la modification.
Il vaut mieux donner les noms de fichier sur le ligne de commande.
my @files = @ARGV;
Ok pour cette methode, elle est appliqué.
/^($need)(.*) client (.*)#(.*) view (.*)$/o
voir perldoc perlre pour les informations sur /o.
Cette option permet en effet de :
Benchmark::Timer
Je ne peux malheureusement pas installer de module sur mon serveur ... mais
J'espere que tu peux comprendre mon franglais :)
Oui oui parfaitement ; )))
Geo Kosto wrote:Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo
sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1
105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Je redoute un ralentissement de l'application qui tourne sur le serveur,
Bind 9.3.1, cad un timeout sur des requêtes lorsque le script tourne.
J'ai essaye 2 méthodes, mais la charge CPU ne se reduit pas, j'en
cherche
donc une autre.
1 - Passer les fichiers dans une liste, ensuite utiliser la liste pour
compter.
@liste=("queries.log", "queries.log.0", "queries.log.1",
"queries.log.2");
foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier:
$!";
while (<FIC>) {
push (@liste_ip, <FIC>);
};
};
close (FIC);
Ca marchera pas: tu lis de FIC deux fois chaque tour. Aussi, il vaut
mieux utiliser un hash, sinon on va chercher l'addresse DNS chaque fois
pour chaque ligne.
Le deuxième exemple est mieux.
2 - Lire chaque fichier et traiter ligne à ligne.
my $today = time();
my $minus=$today - 3600;
my $need = strftime "%d-%b-%Y %H", localtime($minus);
@liste=("queries.log", "queries.log.0",
"queries.log.1","queries.log.2");
Il vaut mieux donner les noms de fichier sur le ligne de commande.
my @files = @ARGV;foreach $fichier (@liste) {
open(FIC, "< $fichier") || die "Erreur ouverture du fichier $fichier:
$!";
while ($line = <FIC>) {
chomp ($line);
if ($line =~ /^($need)(.*) client (.*)#(.*) view (.*)$/)
Le problème ici est que le regex est calculé chaque fois, mais $need se
change jamais. Mettre /o après le regex.
/^($need)(.*) client (.*)#(.*) view (.*)$/o
voir perldoc perlre pour les informations sur /o.
Aussi, utiliser
Benchmark::Timer
afin d'observer bien la difference en performance.{
$total{$3} += 1;
}
};
};
close (FIC);
J'espere que tu peux comprendre mon franglais :)
Mark
Geo Kosto wrote:Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo
sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1
105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Bonjour,
Ne pouvez-vous pas concevoir autrement ? Déjà vous pouvez, à la fin de
votre cycle d'analyse, stocker dans un fichier la position de la
dernière ligne. L'heure suivante il suffit de commencer l'analyse à la
position précédente.
Oui en effet, j'avais penser faire un flag pour determiner la ligne de
Une autre méthode serait peut-être de faire un 'tail' sur ces 4
fichiers. L'analyse se ferait alors au fur et à mesure de vos lignes de
logs, ce qui consommera autant de CPU mais reparti sur 1 heure au lieu
de 3 minutes : pas de bloquage de la machine.
Le parse ne doit pas exceder 5 minutes, car d'autres scripts attendent le
Si ces 2 solutions ne sont pas possibles, vous pouvez toujours lancer le
script en priorité basse, il n'utilisera alors que du CPU disponible.
Oui, le nice fonctionne tres bien, trop bien en fait, car on depasse le
A+
Merci pour vos conseils.
--
Séb
Georges
Geo Kosto wrote:
Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo
sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1
105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Bonjour,
Ne pouvez-vous pas concevoir autrement ? Déjà vous pouvez, à la fin de
votre cycle d'analyse, stocker dans un fichier la position de la
dernière ligne. L'heure suivante il suffit de commencer l'analyse à la
position précédente.
Oui en effet, j'avais penser faire un flag pour determiner la ligne de
Une autre méthode serait peut-être de faire un 'tail' sur ces 4
fichiers. L'analyse se ferait alors au fur et à mesure de vos lignes de
logs, ce qui consommera autant de CPU mais reparti sur 1 heure au lieu
de 3 minutes : pas de bloquage de la machine.
Le parse ne doit pas exceder 5 minutes, car d'autres scripts attendent le
Si ces 2 solutions ne sont pas possibles, vous pouvez toujours lancer le
script en priorité basse, il n'utilisera alors que du CPU disponible.
Oui, le nice fonctionne tres bien, trop bien en fait, car on depasse le
A+
Merci pour vos conseils.
--
Séb
Georges
Geo Kosto wrote:Bonjour,
Quelqu'un parmi vous aurait il une idée pour réduire la consommation des
ressources lors de l'exécution d'un script ?
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo
sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1
105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Bonjour,
Ne pouvez-vous pas concevoir autrement ? Déjà vous pouvez, à la fin de
votre cycle d'analyse, stocker dans un fichier la position de la
dernière ligne. L'heure suivante il suffit de commencer l'analyse à la
position précédente.
Oui en effet, j'avais penser faire un flag pour determiner la ligne de
Une autre méthode serait peut-être de faire un 'tail' sur ces 4
fichiers. L'analyse se ferait alors au fur et à mesure de vos lignes de
logs, ce qui consommera autant de CPU mais reparti sur 1 heure au lieu
de 3 minutes : pas de bloquage de la machine.
Le parse ne doit pas exceder 5 minutes, car d'autres scripts attendent le
Si ces 2 solutions ne sont pas possibles, vous pouvez toujours lancer le
script en priorité basse, il n'utilisera alors que du CPU disponible.
Oui, le nice fonctionne tres bien, trop bien en fait, car on depasse le
A+
Merci pour vos conseils.
--
Séb
Georges
Mais je pense que traiter environ 600 000 ligne sans charge CPU tiendrait du
miracle.
Tu pourrais "nice" le processus.
Je pense peux être faire un pré traitement, un grep sur la date ainsi
j'aurais un seul fichier a parser.
Probablement c'est possible de le faire avec "at" où "cron", et faire
Merci
De rien.
Mais je pense que traiter environ 600 000 ligne sans charge CPU tiendrait du
miracle.
Tu pourrais "nice" le processus.
Je pense peux être faire un pré traitement, un grep sur la date ainsi
j'aurais un seul fichier a parser.
Probablement c'est possible de le faire avec "at" où "cron", et faire
Merci
De rien.
Mais je pense que traiter environ 600 000 ligne sans charge CPU tiendrait du
miracle.
Tu pourrais "nice" le processus.
Je pense peux être faire un pré traitement, un grep sur la date ainsi
j'aurais un seul fichier a parser.
Probablement c'est possible de le faire avec "at" où "cron", et faire
Merci
De rien.
Tu pourrais "nice" le processus.
eg
Proc::NiceSleep
C'est plutot cool comme module, mais je ne peux pas l'installer ( prb
Je pense peux être faire un pré traitement, un grep sur la date ainsi
j'aurais un seul fichier a parser.
Probablement c'est possible de le faire avec "at" où "cron", et faire
marcher le processus à , per exemple, 02h00, quand la machine n'est pas
trop chargé.
Je vais te detailler le but complet de la manoeuvre.
De rien.
A mais merci bcp encore une fois.
Mark
Georges
Tu pourrais "nice" le processus.
eg
Proc::NiceSleep
C'est plutot cool comme module, mais je ne peux pas l'installer ( prb
Je pense peux être faire un pré traitement, un grep sur la date ainsi
j'aurais un seul fichier a parser.
Probablement c'est possible de le faire avec "at" où "cron", et faire
marcher le processus à , per exemple, 02h00, quand la machine n'est pas
trop chargé.
Je vais te detailler le but complet de la manoeuvre.
De rien.
A mais merci bcp encore une fois.
Mark
Georges
Tu pourrais "nice" le processus.
eg
Proc::NiceSleep
C'est plutot cool comme module, mais je ne peux pas l'installer ( prb
Je pense peux être faire un pré traitement, un grep sur la date ainsi
j'aurais un seul fichier a parser.
Probablement c'est possible de le faire avec "at" où "cron", et faire
marcher le processus à , per exemple, 02h00, quand la machine n'est pas
trop chargé.
Je vais te detailler le but complet de la manoeuvre.
De rien.
A mais merci bcp encore une fois.
Mark
Georges
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1 105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Je redoute un ralentissement de l'application qui tourne sur le serveur,
Bind 9.3.1, cad un timeout sur des requêtes lorsque le script tourne.
J'ai essaye 2 méthodes, mais la charge CPU ne se reduit pas, j'en cherche
donc une autre.
1 - Passer les fichiers dans une liste, ensuite utiliser la liste pour
compter.
2 - Lire chaque fichier et traiter ligne à ligne.
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1 105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Je redoute un ralentissement de l'application qui tourne sur le serveur,
Bind 9.3.1, cad un timeout sur des requêtes lorsque le script tourne.
J'ai essaye 2 méthodes, mais la charge CPU ne se reduit pas, j'en cherche
donc une autre.
1 - Passer les fichiers dans une liste, ensuite utiliser la liste pour
compter.
2 - Lire chaque fichier et traiter ligne à ligne.
La problématique est la suivante, je parse 4 fichiers de log de 50 Mo sur
des DNS pour récupérer les IP toutes les heures sur des station Sun T1 105,
et je me rend compte que la consommation CPU atteint les 99% durant 3
minutes !!!
Je redoute un ralentissement de l'application qui tourne sur le serveur,
Bind 9.3.1, cad un timeout sur des requêtes lorsque le script tourne.
J'ai essaye 2 méthodes, mais la charge CPU ne se reduit pas, j'en cherche
donc une autre.
1 - Passer les fichiers dans une liste, ensuite utiliser la liste pour
compter.
2 - Lire chaque fichier et traiter ligne à ligne.
Tu pourrais "nice" le processus.
eg
Proc::NiceSleep
C'est plutot cool comme module, mais je ne peux pas l'installer ( prb
secu ). J'ai utiliser le shell pour le lancer, ca marche mais c'est trop
long.
Je vais te detailler le but complet de la manoeuvre.
J'ai 14 DNS CACHE, sur lesquels mes clients viennent se connecter.
Malheureusement, la mode des tryens, spyware et autres consomme un nombre
grandissant de requetes DNS ( ex : 1 000 000 pour un client sur une heure il
y a une semaine !!! ).
On peut pas bloquer / reparer le client? :)
Donc le but du script est de parser les logs de Bind, pour ensuite alimenter
une blackliste et bloquer les abus. Cela marche en heure - 1 et dure 24h00.
C'est pourquoi j'ai besoin d'un traitement toutes les heures pour capturer
les nouvelles ip "strange".
Une autre méthode serait peut-être de faire un 'tail' sur ces 4 fichiers.
L'analyse se ferait alors au fur et à mesure de vos lignes de logs,
ce qui
consommera autant de CPU mais reparti sur 1 heure au lieu
de 3 minutes : pas de bloquage de la machine.
Tu pourrais "nice" le processus.
eg
Proc::NiceSleep
C'est plutot cool comme module, mais je ne peux pas l'installer ( prb
secu ). J'ai utiliser le shell pour le lancer, ca marche mais c'est trop
long.
Je vais te detailler le but complet de la manoeuvre.
J'ai 14 DNS CACHE, sur lesquels mes clients viennent se connecter.
Malheureusement, la mode des tryens, spyware et autres consomme un nombre
grandissant de requetes DNS ( ex : 1 000 000 pour un client sur une heure il
y a une semaine !!! ).
On peut pas bloquer / reparer le client? :)
Donc le but du script est de parser les logs de Bind, pour ensuite alimenter
une blackliste et bloquer les abus. Cela marche en heure - 1 et dure 24h00.
C'est pourquoi j'ai besoin d'un traitement toutes les heures pour capturer
les nouvelles ip "strange".
Une autre méthode serait peut-être de faire un 'tail' sur ces 4 fichiers.
L'analyse se ferait alors au fur et à mesure de vos lignes de logs,
ce qui
consommera autant de CPU mais reparti sur 1 heure au lieu
de 3 minutes : pas de bloquage de la machine.
Tu pourrais "nice" le processus.
eg
Proc::NiceSleep
C'est plutot cool comme module, mais je ne peux pas l'installer ( prb
secu ). J'ai utiliser le shell pour le lancer, ca marche mais c'est trop
long.
Je vais te detailler le but complet de la manoeuvre.
J'ai 14 DNS CACHE, sur lesquels mes clients viennent se connecter.
Malheureusement, la mode des tryens, spyware et autres consomme un nombre
grandissant de requetes DNS ( ex : 1 000 000 pour un client sur une heure il
y a une semaine !!! ).
On peut pas bloquer / reparer le client? :)
Donc le but du script est de parser les logs de Bind, pour ensuite alimenter
une blackliste et bloquer les abus. Cela marche en heure - 1 et dure 24h00.
C'est pourquoi j'ai besoin d'un traitement toutes les heures pour capturer
les nouvelles ip "strange".
Une autre méthode serait peut-être de faire un 'tail' sur ces 4 fichiers.
L'analyse se ferait alors au fur et à mesure de vos lignes de logs,
ce qui
consommera autant de CPU mais reparti sur 1 heure au lieu
de 3 minutes : pas de bloquage de la machine.
Je vais te detailler le but complet de la manoeuvre.
J'ai 14 DNS CACHE, sur lesquels mes clients viennent se connecter.
Malheureusement, la mode des tryens, spyware et autres consomme un nombre
grandissant de requetes DNS ( ex : 1 000 000 pour un client sur une heure il
y a une semaine !!! ).
Donc le but du script est de parser les logs de Bind, pour ensuite alimenter
une blackliste et bloquer les abus. Cela marche en heure - 1 et dure 24h00.
C'est pourquoi j'ai besoin d'un traitement toutes les heures pour capturer
les nouvelles ip "strange".
Je vais te detailler le but complet de la manoeuvre.
J'ai 14 DNS CACHE, sur lesquels mes clients viennent se connecter.
Malheureusement, la mode des tryens, spyware et autres consomme un nombre
grandissant de requetes DNS ( ex : 1 000 000 pour un client sur une heure il
y a une semaine !!! ).
Donc le but du script est de parser les logs de Bind, pour ensuite alimenter
une blackliste et bloquer les abus. Cela marche en heure - 1 et dure 24h00.
C'est pourquoi j'ai besoin d'un traitement toutes les heures pour capturer
les nouvelles ip "strange".
Je vais te detailler le but complet de la manoeuvre.
J'ai 14 DNS CACHE, sur lesquels mes clients viennent se connecter.
Malheureusement, la mode des tryens, spyware et autres consomme un nombre
grandissant de requetes DNS ( ex : 1 000 000 pour un client sur une heure il
y a une semaine !!! ).
Donc le but du script est de parser les logs de Bind, pour ensuite alimenter
une blackliste et bloquer les abus. Cela marche en heure - 1 et dure 24h00.
C'est pourquoi j'ai besoin d'un traitement toutes les heures pour capturer
les nouvelles ip "strange".
C'est possible d'installer les modules sans avoir root. Si ça c'est la
problème, lire
perldoc -q lib
Le problème c'est ma cellule securité, elle refuse d'installer quoi que se
On peut pas bloquer / reparer le client? :)
C'est le but finale,identifier, informer et bloquer si il n'y a pas de mise
Je pense que c'est l'idée la meilleur. En fait, j'ai fait ça il y a
plusieurs années pour lire les logs d'une système d'email pour 30000
utilisateurs en temps réel, afin d'ajouter les addresses dans une base a
données d'adresses qui pouvaient envoyer les emails ailleurs
(third-party relaying). Avec File::Tail, c'est facile.
Je vais me pencher sur cette solution des que possible, ca semble repondre a
C'est possible d'installer les modules sans avoir root. Si ça c'est la
problème, lire
perldoc -q lib
Le problème c'est ma cellule securité, elle refuse d'installer quoi que se
On peut pas bloquer / reparer le client? :)
C'est le but finale,identifier, informer et bloquer si il n'y a pas de mise
Je pense que c'est l'idée la meilleur. En fait, j'ai fait ça il y a
plusieurs années pour lire les logs d'une système d'email pour 30000
utilisateurs en temps réel, afin d'ajouter les addresses dans une base a
données d'adresses qui pouvaient envoyer les emails ailleurs
(third-party relaying). Avec File::Tail, c'est facile.
Je vais me pencher sur cette solution des que possible, ca semble repondre a
C'est possible d'installer les modules sans avoir root. Si ça c'est la
problème, lire
perldoc -q lib
Le problème c'est ma cellule securité, elle refuse d'installer quoi que se
On peut pas bloquer / reparer le client? :)
C'est le but finale,identifier, informer et bloquer si il n'y a pas de mise
Je pense que c'est l'idée la meilleur. En fait, j'ai fait ça il y a
plusieurs années pour lire les logs d'une système d'email pour 30000
utilisateurs en temps réel, afin d'ajouter les addresses dans une base a
données d'adresses qui pouvaient envoyer les emails ailleurs
(third-party relaying). Avec File::Tail, c'est facile.
Je vais me pencher sur cette solution des que possible, ca semble repondre a