1. Contexte
Un bon logiciel doit avoir les caractéristiques suivantes:
1: la facilité d'utilisation du logiciel
La naissance du logiciel est de résoudre des problèmes spécifiques, tels que le framework MVC maintenant populaire, pas MVC développement précoce lorsqu'un grand degré de couplage, mise à jour post-entretien à engager des coûts, difficile, donc il est né framework MVC, par exemple le système d'OA combiné avec la résolution des problèmes de l'entreprise, tels que QQ, micro-canal, chat en temps réel pour résoudre les problèmes du peuple de communication à distance.
2: La stabilité du logiciel
Après la question des solutions logicielles de services publics, le besoin urgent de résoudre le problème est la stabilité du logiciel. système en ligne général transportera une entreprise commerciale, un impact direct sur la stabilité du système si l'entreprise peut fonctionner correctement.
3: Spécification du code
casernes fer de soldats, pour atteindre plus seulement de bonnes fonctions logicielles. architecture générale, un bloc fonctionnel, les commentaires de code, d'évolutivité et d'autres questions doivent également tenir compte, après tout, dans un cycle de vie du logiciel, impliqué trop grand nombre, le personnel créatif également soumis à soixante. Il est donc un code normatif louable.
4: Mise à niveau pour maintenir la compatibilité avant
Si un bon logiciel normalement utilisé, mais la mise à niveau est de plus en plus amorphe, ou la stabilité considérablement réduite après la mise à niveau, afin d'obtenir également un bon logiciel.
5: Manuel de base
Les documents, une utilisation simple et efficace du manuel, est roi du programme. Permet aux utilisateurs de claire, fonctionnelle, l'architecture, des idées de conception, le code, et ainsi de suite.
2, analyse des besoins:
Avec le développement des affaires de l'entreprise, en soutenant une variété de systèmes d'affaires de plus en plus, pour les dépressions d'affaires normales de l'entreprise, un besoin urgent de surveiller le fonctionnement de ces systèmes maintenant, de sorte que le problème même si elle est trouvée, afin de maximiser réduire l'impact sur l'entreprise.
Le système actuel de classification sont:
1) Il y a application Web Tomcat
2) une demande d'applications Java indépendant
3) ont exécuter le script sous Linux
4) il existe un cadre de regroupement à grande échelle (Zookeeper, Hadoop, Tempête, SRP .....)
5) Système d'exploitation exécutant log de (en haut)
Les principales exigences fonctionnelles sont divisées en: système de surveillance du contenu journal, filtrées selon certaines règles, nous avons trouvé le problème après une alarme par SMS et e-mail.
3, l'analyse fonctionnelle:
Entrée de données:
Connexion de données: utilisation client acquiert des données de canal chaque système;
données Règles: Nom du système d'entrée d'utilisateur / directeur général des règles de départ par page;
Stockage des données:
Utiliser les données flume collectées et stockées dans le cluster kafka
calcul des données:
Utiliser la programmation de tempête sur le journal, rencontrera les règles de filtrage de l'information, par e-mail et alertes SMS enregistrés dans la base de données.
Les données montrent:
page de gestion pour afficher les informations d'établir des règles. Le système est responsable des personnes, des informations de contact, des informations de déclenchement et d'autres détails
4, la conception de l'architecture générale
L'architecture principale de l'application: + kafka + flume + tempête + mysql flux de données web java est la suivante:
1: l'application utilise LOG4J pour générer journal
2: journal de déploiement des applications de surveillance des clients flume générés et envoyés à kafka groupe
3: bec tempête tirant les données de consommation de Kafka, une par une règle de filtrage est déterminé pour chaque journal, un journal de conformité avec les règles pour les messages d'alerte.
4: Enregistrez le dernier message d'avertissement à la base de données MySQL à gérer.
conception Flume
est un des services flume distribués, sécurisés, disponibles, collecte, l'agrégation, la transmission de données du journal.
Il est basé sur une architecture de flux de données, simple et flexible. Il est robuste. La tolérance aux pannes, le basculement, des mécanismes de recouvrement. Il offre un moyen simple et le modèle de base de données évolutive qui permet programme d'analyse en ligne
a1.sources = r1
a1.channels = c1
a1.sinks = k1
a1.sources.r1.type = exec
a1.sources.r1.command = tail -F /export/data/flume_source/click_log/info.log
a1.sources.r1.channels = c1
a1.sources.r1.interceptors = i1
a1.sources.r1.interceptors.i1.type = cn.itcast.flume.AppInterceptor$AppInterceptorBuilder
# 用来标识 日志所属系统
a1.sources.r1.interceptors.i1.appId = 1
a1.channels.c1.type=memory
a1.channels.c1.capacity=10000
a1.channels.c1.transactionCapacity=100
a1.sinks.k1.type = org.apache.flume.sink.kafka.KafkaSink
a1.sinks.k1.topic = log_monitor
a1.sinks.k1.brokerList = HADOOP01:9092
a1.sinks.k1.requiredAcks = 1
a1.sinks.k1.batchSize = 20
a1.sinks.k1.channel = c1intercepteur
package cn.itcast.flume;
import org.apache.commons.lang.StringUtils;
import org.apache.flume.Context;
import org.apache.flume.Event;
import org.apache.flume.interceptor.Interceptor;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
/**
* 1、实现一个InterceptorBuilder接口
* 2、InterceptorBuilder中有个configuref方法,通过configure获取配置文件中的相应key。
* 3、InterceptorBuilder中有个builder方法，通过builder创建一个自定义的MyAppInterceptor
* 4、AppInterceptor中有两个方法，一个是批处理，一个单条处理，将批处理的逻辑转换为单条处理
* 5、需要在单条数据中添加 appid，由于appid是变量。需要在AppInterceptor的构造器中传入一些参数。
* 6、为自定义的AppInterceptor创建有参构造器，将需要的参数传入进来。
*/
public class AppInterceptor implements Interceptor {
//4、定义成员变量appId，用来接收从配置文件中读取的信息
private String appId;
public AppInterceptor(String appId) {
this.appId = appId;
}
/**
* 单条数据进行处理
* @param event
* @return
*/
public Event intercept(Event event) {
String message = null;
try {
message = new String(event.getBody(), "utf-8");
} catch (UnsupportedEncodingException e) {
message = new String(event.getBody());
}
//处理逻辑
if (StringUtils.isNotBlank(message)) {
message = "aid:"+appId+"||msg:" +message;
event.setBody(message.getBytes());
//正常逻辑应该执行到这里
return event;
}
//如果执行以下代码，表示拦截失效了。
return event;
}
/**
* 批量数据数据进行处理
* @param list
* @return
*/
public List<Event> intercept(List<Event> list) {
List<Event> resultList = new ArrayList<Event>();
for (Event event : list) {
Event r = intercept(event);
if (r != null) {
resultList.add(r);
}
}
return resultList;
}
public void close() {
}
public void initialize() {
}
public static class AppInterceptorBuilder implements Interceptor.Builder{
//1、获取配置文件的appId
private String appId;
public Interceptor build() {
//3、构造拦截器
return new AppInterceptor(appId);
}
public void configure(Context context) {
//2、当出现default之后，就是点击流告警系统
this.appId = context.getString("appId","default");
System.out.println("appId:"+appId);
}
}
}
Kakfa Conception
kafka est une file d'attente de message distribué: les producteurs, les consommateurs fonctionnent
Des fragments et nombre de copies est défini:
1) créer un sujet all_app_log
2) Indiquez la tranche de données, le nombre de copies ( en supposant qu'il 3T à l'échelle réelle du journal) nécessite trois copies de 10 fragments
3T données du journal
La quantité moyenne de données par seconde: 3T / 24H = 0.125T = 125G / 60 M = 20 g / 60S = 20000m / 60S = 333m
Montant de crête des données: 333m * 3
Tenez compte des activités de pointe: 333m * 3 * 3
Conclusion: les secondes données de processus nécessaires à la 3G, les données de valeur de quantité théorique de kafka est 600m / S, la traduction réelle 300M / S
3G / 300M = 10 fragments
3) Comment calculer le nombre de copies
courtier nombre supérieur à 10, seul le nombre de copies est égal à 2
numéro de courtier inférieur à 10, le nombre d'exemplaires requis est de 3
4) kafka données stratégiques stockées pendant 168 heures de stockage de données 3 * 3T * 7D = 63T de
kafka-topics.sh --create --zookeeper hadoop01:2181 --replication-factor 3 --partitions 10 --topic all_app_log
