欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Kafka使用入門教程第1/2頁

 更新時間:2015年12月14日 21:37:41   投稿:mdxy-dxy  
Kafka是一個分布式的、可分區(qū)的、可復(fù)制的消息系統(tǒng)。它提供了普通消息系統(tǒng)的功能,但具有自己獨特的設(shè)計。這個獨特的設(shè)計是什么樣的呢

介紹

Kafka是一個分布式的、可分區(qū)的、可復(fù)制的消息系統(tǒng)。它提供了普通消息系統(tǒng)的功能,但具有自己獨特的設(shè)計。這個獨特的設(shè)計是什么樣的呢?

首先讓我們看幾個基本的消息系統(tǒng)術(shù)語:

•Kafka將消息以topic為單位進行歸納。
•將向Kafka topic發(fā)布消息的程序成為producers.
•將預(yù)訂topics并消費消息的程序成為consumer.
•Kafka以集群的方式運行,可以由一個或多個服務(wù)組成,每個服務(wù)叫做一個broker.
producers通過網(wǎng)絡(luò)將消息發(fā)送到Kafka集群,集群向消費者提供消息,如下圖所示:

客戶端和服務(wù)端通過TCP協(xié)議通信。Kafka提供了Java客戶端,并且對多種語言都提供了支持。

Topics 和Logs
先來看一下Kafka提供的一個抽象概念:topic.
一個topic是對一組消息的歸納。對每個topic,Kafka 對它的日志進行了分區(qū),如下圖所示:
每個分區(qū)都由一系列有序的、不可變的消息組成,這些消息被連續(xù)的追加到分區(qū)中。分區(qū)中的每個消息都有一個連續(xù)的序列號叫做offset,用來在分區(qū)中唯一的標識這個消息。
 
在一個可配置的時間段內(nèi),Kafka集群保留所有發(fā)布的消息,不管這些消息有沒有被消費。比如,如果消息的保存策略被設(shè)置為2天,那么在一個消息被發(fā)布的兩天時間內(nèi),它都是可以被消費的。之后它將被丟棄以釋放空間。Kafka的性能是和數(shù)據(jù)量無關(guān)的常量級的,所以保留太多的數(shù)據(jù)并不是問題。
 
實際上每個consumer唯一需要維護的數(shù)據(jù)是消息在日志中的位置,也就是offset.這個offset有consumer來維護:一般情況下隨著consumer不斷的讀取消息,這offset的值不斷增加,但其實consumer可以以任意的順序讀取消息,比如它可以將offset設(shè)置成為一個舊的值來重讀之前的消息。
 
以上特點的結(jié)合,使Kafka consumers非常的輕量級:它們可以在不對集群和其他consumer造成影響的情況下讀取消息。你可以使用命令行來"tail"消息而不會對其他正在消費消息的consumer造成影響。
 
將日志分區(qū)可以達到以下目的:首先這使得每個日志的數(shù)量不會太大,可以在單個服務(wù)上保存。另外每個分區(qū)可以單獨發(fā)布和消費,為并發(fā)操作topic提供了一種可能。
分布式
 每個分區(qū)在Kafka集群的若干服務(wù)中都有副本,這樣這些持有副本的服務(wù)可以共同處理數(shù)據(jù)和請求,副本數(shù)量是可以配置的。副本使Kafka具備了容錯能力。
 每個分區(qū)都由一個服務(wù)器作為“l(fā)eader”,零或若干服務(wù)器作為“followers”,leader負責處理消息的讀和寫,followers則去復(fù)制leader.如果leader down了,followers中的一臺則會自動成為leader。集群中的每個服務(wù)都會同時扮演兩個角色:作為它所持有的一部分分區(qū)的leader,同時作為其他分區(qū)的followers,這樣集群就會據(jù)有較好的負載均衡。
Producers
 Producer將消息發(fā)布到它指定的topic中,并負責決定發(fā)布到哪個分區(qū)。通常簡單的由負載均衡機制隨機選擇分區(qū),但也可以通過特定的分區(qū)函數(shù)選擇分區(qū)。使用的更多的是第二種。

Consumers
發(fā)布消息通常有兩種模式:隊列模式(queuing)和發(fā)布-訂閱模式(publish-subscribe)。隊列模式中,consumers可以同時從服務(wù)端讀取消息,每個消息只被其中一個consumer讀到;發(fā)布-訂閱模式中消息被廣播到所有的consumer中。Consumers可以加入一個consumer 組,共同競爭一個topic,topic中的消息將被分發(fā)到組中的一個成員中。同一組中的consumer可以在不同的程序中,也可以在不同的機器上。如果所有的consumer都在一個組中,這就成為了傳統(tǒng)的隊列模式,在各consumer中實現(xiàn)負載均衡。如果所有的consumer都不在不同的組中,這就成為了發(fā)布-訂閱模式,所有的消息都被分發(fā)到所有的consumer中。更常見的是,每個topic都有若干數(shù)量的consumer組,每個組都是一個邏輯上的“訂閱者”,為了容錯和更好的穩(wěn)定性,每個組由若干consumer組成。這其實就是一個發(fā)布-訂閱模式,只不過訂閱者是個組而不是單個consumer。
更常見的是,每個topic都有若干數(shù)量的consumer組,每個組都是一個邏輯上的“訂閱者”,為了容錯和更好的穩(wěn)定性,每個組由若干consumer組成。這其實就是一個發(fā)布-訂閱模式,只不過訂閱者是個組而不是單個consumer。
由兩個機器組成的集群擁有4個分區(qū) (P0-P3) 2個consumer組. A組有兩個consumerB組有4個
 
相比傳統(tǒng)的消息系統(tǒng),Kafka可以很好的保證有序性。
傳統(tǒng)的隊列在服務(wù)器上保存有序的消息,如果多個consumers同時從這個服務(wù)器消費消息,服務(wù)器就會以消息存儲的順序向consumer分發(fā)消息。雖然服務(wù)器按順序發(fā)布消息,但是消息是被異步的分發(fā)到各consumer上,所以當消息到達時可能已經(jīng)失去了原來的順序,這意味著并發(fā)消費將導致順序錯亂。為了避免故障,這樣的消息系統(tǒng)通常使用“專用consumer”的概念,其實就是只允許一個消費者消費消息,當然這就意味著失去了并發(fā)性。
 
在這方面Kafka做的更好,通過分區(qū)的概念,Kafka可以在多個consumer組并發(fā)的情況下提供較好的有序性和負載均衡。將每個分區(qū)分只分發(fā)給一個consumer組,這樣一個分區(qū)就只被這個組的一個consumer消費,就可以順序的消費這個分區(qū)的消息。因為有多個分區(qū),依然可以在多個consumer組之間進行負載均衡。注意consumer組的數(shù)量不能多于分區(qū)的數(shù)量,也就是有多少分區(qū)就允許多少并發(fā)消費。
 
Kafka只能保證一個分區(qū)之內(nèi)消息的有序性,在不同的分區(qū)之間是不可以的,這已經(jīng)可以滿足大部分應(yīng)用的需求。如果需要topic中所有消息的有序性,那就只能讓這個topic只有一個分區(qū),當然也就只有一個consumer組消費它。

接下來一步一步搭建Kafka運行環(huán)境。

Step 1: 下載Kafka點擊下載最新的版本并解壓.
> tar -xzf kafka_2.9.2-0.8.1.1.tgz
> cd kafka_2.9.2-0.8.1.1
Step 2: 啟動服務(wù)
Kafka用到了Zookeeper,所有首先啟動Zookper,下面簡單的啟用一個單實例的Zookkeeper服務(wù)。可以在命令的結(jié)尾加個&符號,這樣就可以啟動后離開控制臺。
> bin/zookeeper-server-start.sh config/zookeeper.properties &[2013-04-22 15:01:37,495] INFO Reading configuration from: config/zookeeper.properties (org.apache.zookeeper.server.quorum.QuorumPeerConfig)...
現(xiàn)在啟動Kafka:
> bin/kafka-server-start.sh config/server.properties[2013-04-22 15:01:47,028] INFO Verifying properties (kafka.utils.VerifiableProperties)[2013-04-22 15:01:47,051] INFO Property socket.send.buffer.bytes is overridden to 1048576 (kafka.utils.VerifiableProperties)...
Step 3: 創(chuàng)建 topic
創(chuàng)建一個叫做“test”的topic,它只有一個分區(qū),一個副本。
> bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test
可以通過list命令查看創(chuàng)建的topic:
> bin/kafka-topics.sh --list --zookeeper localhost:2181test
除了手動創(chuàng)建topic,還可以配置broker讓它自動創(chuàng)建topic.Step 4:發(fā)送消息.
Kafka 使用一個簡單的命令行producer,從文件中或者從標準輸入中讀取消息并發(fā)送到服務(wù)端。默認的每條命令將發(fā)送一條消息。

運行producer并在控制臺中輸一些消息,這些消息將被發(fā)送到服務(wù)端:
> bin/kafka-console-producer.sh --broker-list localhost:9092 --topic test This is a messageThis is another message
ctrl+c可以退出發(fā)送。
Step 5: 啟動consumerKafka also has a command line consumer that will dump out messages to standard output.
Kafka也有一個命令行consumer可以讀取消息并輸出到標準輸出:
> bin/kafka-console-consumer.sh --zookeeper localhost:2181 --topic test --from-beginningThis is a messageThis is another message
你在一個終端中運行consumer命令行,另一個終端中運行producer命令行,就可以在一個終端輸入消息,另一個終端讀取消息。
這兩個命令都有自己的可選參數(shù),可以在運行的時候不加任何參數(shù)可以看到幫助信息。
 
Step 6: 搭建一個多個broker的集群
剛才只是啟動了單個broker,現(xiàn)在啟動有3個broker組成的集群,這些broker節(jié)點也都是在本機上的:
首先為每個節(jié)點編寫配置文件:
 
> cp config/server.properties config/server-1.properties
> cp config/server.properties config/server-2.properties
在拷貝出的新文件中添加以下參數(shù):
config/server-1.properties: broker.id=1 port=9093 log.dir=/tmp/kafka-logs-1 config/server-2.properties: broker.id=2 port=9094 log.dir=/tmp/kafka-logs-2
broker.id在集群中唯一的標注一個節(jié)點,因為在同一個機器上,所以必須制定不同的端口和日志文件,避免數(shù)據(jù)被覆蓋。
 
We already have Zookeeper and our single node started, so we just need to start the two new nodes:
剛才已經(jīng)啟動可Zookeeper和一個節(jié)點,現(xiàn)在啟動另外兩個節(jié)點:
> bin/kafka-server-start.sh config/server-1.properties &...> bin/kafka-server-start.sh config/server-2.properties &...
創(chuàng)建一個擁有3個副本的topic:
> bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 3 --partitions 1 --topic my-replicated-topic
現(xiàn)在我們搭建了一個集群,怎么知道每個節(jié)點的信息呢?運行“"describe topics”命令就可以了:
> bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic my-replicated-topicTopic:my-replicated-topic  PartitionCount:1  ReplicationFactor:3  Configs:  Topic: my-replicated-topic  Partition: 0 Leader: 1  Replicas: 1,2,0 Isr: 1,2,0
下面解釋一下這些輸出。第一行是對所有分區(qū)的一個描述,然后每個分區(qū)都會對應(yīng)一行,因為我們只有一個分區(qū)所以下面就只加了一行。
leader:負責處理消息的讀和寫,leader是從所有節(jié)點中隨機選擇的.replicas:列出了所有的副本節(jié)點,不管節(jié)點是否在服務(wù)中.isr:是正在服務(wù)中的節(jié)點.
在我們的例子中,節(jié)點1是作為leader運行。

向topic發(fā)送消息:

> bin/kafka-console-producer.sh --broker-list localhost:9092 --topic my-replicated-topic...my test message 1my test message 2^C 
消費這些消息:
> bin/kafka-console-consumer.sh --zookeeper localhost:2181 --from-beginning --topic my-replicated-topic...my test message 1my test message 2^C
測試一下容錯能力.Broker 1作為leader運行,現(xiàn)在我們kill掉它:
> ps | grep server-1.properties7564 ttys002 0:15.91 /System/Library/Frameworks/JavaVM.framework/Versions/1.6/Home/bin/java...> kill -9 7564
另外一個節(jié)點被選做了leader,node 1 不再出現(xiàn)在 in-sync 副本列表中:
> bin/kafka-topics.sh --describe --zookeeper localhost:218192 --topic my-replicated-topicTopic:my-replicated-topic  PartitionCount:1  ReplicationFactor:3  Configs:  Topic: my-replicated-topic  Partition: 0 Leader: 2  Replicas: 1,2,0 Isr: 2,0
雖然最初負責續(xù)寫消息的leader down掉了,但之前的消息還是可以消費的:
> bin/kafka-console-consumer.sh --zookeeper localhost:2181 --from-beginning --topic my-replicated-topic...my test message 1my test message 2^C
看來Kafka的容錯機制還是不錯的。
上篇文章中我們搭建了kafka的服務(wù)器,并可以使用Kafka的命令行工具創(chuàng)建topic,發(fā)送和接收消息。
下面我們來搭建kafka的開發(fā)環(huán)境。
添加依賴
搭建開發(fā)環(huán)境需要引入kafka的jar包,一種方式是將Kafka安裝包中l(wèi)ib下的jar包加入到項目的classpath中,這種比較簡單了。不過我們使用另一種更加流行的方式:使用maven管理jar包依賴。
創(chuàng)建好maven項目后,在pom.xml中添加以下依賴:
復(fù)制代碼 代碼如下:

<dependency>
        <groupId> org.apache.kafka</groupId >
        <artifactId> kafka_2.10</artifactId >
        <version> 0.8.0</ version>
</dependency>
添加依賴后你會發(fā)現(xiàn)有兩個jar包的依賴找不到。沒關(guān)系我都幫你想好了,點擊這里下載這兩個jar包,解壓后你有兩種選擇,第一種是使用mvn的install命令將jar包安裝到本地倉庫,另一種是直接將解壓后的文件夾拷貝到mvn本地倉庫的com文件夾下,比如我的本地倉庫是d:\mvn,完成后我的目錄結(jié)構(gòu)是這樣的:

配置程序

首先是一個充當配置文件作用的接口,配置了Kafka的各種連接參數(shù):

package com.sohu.kafkademon;

public interface KafkaProperties
{
 final static String zkConnect = "10.22.10.139:2181";
 final static String groupId = "group1";
 final static String topic = "topic1";
 final static String kafkaServerURL = "10.22.10.139";
 final static int kafkaServerPort = 9092;
 final static int kafkaProducerBufferSize = 64 * 1024;
 final static int connectionTimeOut = 20000;
 final static int reconnectInterval = 10000;
 final static String topic2 = "topic2";
 final static String topic3 = "topic3";
 final static String clientId = "SimpleConsumerDemoClient";
}

producer

package com.sohu.kafkademon;

import java.util.Properties;

import kafka.producer.KeyedMessage;
import kafka.producer.ProducerConfig;

/**
 * @author leicui bourne_cui@163.com
 */
public class KafkaProducer extends Thread
{
 private final kafka.javaapi.producer.Producer<Integer, String> producer;
 private final String topic;
 private final Properties props = new Properties();

 public KafkaProducer(String topic)
 {
  props.put("serializer.class", "kafka.serializer.StringEncoder");
  props.put("metadata.broker.list", "10.22.10.139:9092");
  producer = new kafka.javaapi.producer.Producer<Integer, String>(new ProducerConfig(props));
  this.topic = topic;
 }

 @Override
 public void run() {
  int messageNo = 1;
  while (true)
  {
   String messageStr = new String("Message_" + messageNo);
   System.out.println("Send:" + messageStr);
   producer.send(new KeyedMessage<Integer, String>(topic, messageStr));
   messageNo++;
   try {
    sleep(3000);
   } catch (InterruptedException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
  }
 }

}

consumer

package com.sohu.kafkademon;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import kafka.consumer.ConsumerConfig;
import kafka.consumer.ConsumerIterator;
import kafka.consumer.KafkaStream;
import kafka.javaapi.consumer.ConsumerConnector;

/**
 * @author leicui bourne_cui@163.com
 */
public class KafkaConsumer extends Thread
{
 private final ConsumerConnector consumer;
 private final String topic;

 public KafkaConsumer(String topic)
 {
  consumer = kafka.consumer.Consumer.createJavaConsumerConnector(
    createConsumerConfig());
  this.topic = topic;
 }

 private static ConsumerConfig createConsumerConfig()
 {
  Properties props = new Properties();
  props.put("zookeeper.connect", KafkaProperties.zkConnect);
  props.put("group.id", KafkaProperties.groupId);
  props.put("zookeeper.session.timeout.ms", "40000");
  props.put("zookeeper.sync.time.ms", "200");
  props.put("auto.commit.interval.ms", "1000");
  return new ConsumerConfig(props);
 }

 @Override
 public void run() {
  Map<String, Integer> topicCountMap = new HashMap<String, Integer>();
  topicCountMap.put(topic, new Integer(1));
  Map<String, List<KafkaStream<byte[], byte[]>>> consumerMap = consumer.createMessageStreams(topicCountMap);
  KafkaStream<byte[], byte[]> stream = consumerMap.get(topic).get(0);
  ConsumerIterator<byte[], byte[]> it = stream.iterator();
  while (it.hasNext()) {
   System.out.println("receive:" + new String(it.next().message()));
   try {
    sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
}

運行下面這個程序,就可以進行簡單的發(fā)送接收消息了:簡單的發(fā)送接收

package com.sohu.kafkademon;

/**
 * @author leicui bourne_cui@163.com
 */
public class KafkaConsumerProducerDemo
{
 public static void main(String[] args)
 {
  KafkaProducer producerThread = new KafkaProducer(KafkaProperties.topic);
  producerThread.start();

  KafkaConsumer consumerThread = new KafkaConsumer(KafkaProperties.topic);
  consumerThread.start();
 }
}

高級別的consumer

下面是比較負載的發(fā)送接收的程序:

package com.sohu.kafkademon;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import kafka.consumer.ConsumerConfig;
import kafka.consumer.ConsumerIterator;
import kafka.consumer.KafkaStream;
import kafka.javaapi.consumer.ConsumerConnector;

/**
 * @author leicui bourne_cui@163.com
 */
public class KafkaConsumer extends Thread
{
 private final ConsumerConnector consumer;
 private final String topic;

 public KafkaConsumer(String topic)
 {
  consumer = kafka.consumer.Consumer.createJavaConsumerConnector(
    createConsumerConfig());
  this.topic = topic;
 }

 private static ConsumerConfig createConsumerConfig()
 {
  Properties props = new Properties();
  props.put("zookeeper.connect", KafkaProperties.zkConnect);
  props.put("group.id", KafkaProperties.groupId);
  props.put("zookeeper.session.timeout.ms", "40000");
  props.put("zookeeper.sync.time.ms", "200");
  props.put("auto.commit.interval.ms", "1000");
  return new ConsumerConfig(props);
 }

 @Override
 public void run() {
  Map<String, Integer> topicCountMap = new HashMap<String, Integer>();
  topicCountMap.put(topic, new Integer(1));
  Map<String, List<KafkaStream<byte[], byte[]>>> consumerMap = consumer.createMessageStreams(topicCountMap);
  KafkaStream<byte[], byte[]> stream = consumerMap.get(topic).get(0);
  ConsumerIterator<byte[], byte[]> it = stream.iterator();
  while (it.hasNext()) {
   System.out.println("receive:" + new String(it.next().message()));
   try {
    sleep(3000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
}

不要畏懼文件系統(tǒng)!

Kafka大量依賴文件系統(tǒng)去存儲和緩存消息。對于硬盤有個傳統(tǒng)的觀念是硬盤總是很慢,這使很多人懷疑基于文件系統(tǒng)的架構(gòu)能否提供優(yōu)異的性能。實際上硬盤的快慢完全取決于使用它的方式。設(shè)計良好的硬盤架構(gòu)可以和內(nèi)存一樣快。

在6塊7200轉(zhuǎn)的SATA RAID-5磁盤陣列的線性寫速度差不多是600MB/s,但是隨即寫的速度卻是100k/s,差了差不多6000倍。現(xiàn)代的操作系統(tǒng)都對次做了大量的優(yōu)化,使用了 read-ahead 和 write-behind的技巧,讀取的時候成塊的預(yù)讀取數(shù)據(jù),寫的時候?qū)⒏鞣N微小瑣碎的邏輯寫入組織合并成一次較大的物理寫入。對此的深入討論可以查看這里,它們發(fā)現(xiàn)線性的訪問磁盤,很多時候比隨機的內(nèi)存訪問快得多。

為了提高性能,現(xiàn)代操作系統(tǒng)往往使用內(nèi)存作為磁盤的緩存,現(xiàn)代操作系統(tǒng)樂于把所有空閑內(nèi)存用作磁盤緩存,雖然這可能在緩存回收和重新分配時犧牲一些性能。所有的磁盤讀寫操作都會經(jīng)過這個緩存,這不太可能被繞開除非直接使用I/O。所以雖然每個程序都在自己的線程里只緩存了一份數(shù)據(jù),但在操作系統(tǒng)的緩存里還有一份,這等于存了兩份數(shù)據(jù)。

另外再來討論一下JVM,以下兩個事實是眾所周知的:

•Java對象占用空間是非常大的,差不多是要存儲的數(shù)據(jù)的兩倍甚至更高。

•隨著堆中數(shù)據(jù)量的增加,垃圾回收回變的越來越困難。

基于以上分析,如果把數(shù)據(jù)緩存在內(nèi)存里,因為需要存儲兩份,不得不使用兩倍的內(nèi)存空間,Kafka基于JVM,又不得不將空間再次加倍,再加上要避免GC帶來的性能影響,在一個32G內(nèi)存的機器上,不得不使用到28-30G的內(nèi)存空間。并且當系統(tǒng)重啟的時候,又必須要將數(shù)據(jù)刷到內(nèi)存中( 10GB 內(nèi)存差不多要用10分鐘),就算使用冷刷新(不是一次性刷進內(nèi)存,而是在使用數(shù)據(jù)的時候沒有就刷到內(nèi)存)也會導致最初的時候新能非常慢。但是使用文件系統(tǒng),即使系統(tǒng)重啟了,也不需要刷新數(shù)據(jù)。使用文件系統(tǒng)也簡化了維護數(shù)據(jù)一致性的邏輯。

所以與傳統(tǒng)的將數(shù)據(jù)緩存在內(nèi)存中然后刷到硬盤的設(shè)計不同,Kafka直接將數(shù)據(jù)寫到了文件系統(tǒng)的日志中。

相關(guān)文章

  • Linux環(huán)境下部署Consul集群

    Linux環(huán)境下部署Consul集群

    這篇文章介紹了Linux環(huán)境下部署Consul集群的方法,對大家的學習或者工作具有一定的參考學習價值,需要的朋友們下面隨著小編來一起學習學習吧
    2022-04-04
  • Centos 7.2中雙網(wǎng)卡綁定及相關(guān)問題踩坑記錄

    Centos 7.2中雙網(wǎng)卡綁定及相關(guān)問題踩坑記錄

    最近在工作中遇到了關(guān)于雙網(wǎng)卡綁定的需求,在綁定中發(fā)現(xiàn)了不少的問題,所以這篇文章主要給大家介紹了關(guān)于Centos 7.2中雙網(wǎng)卡綁定及相關(guān)問題踩坑的相關(guān)資料,需要的朋友可以參考借鑒,下面隨著小編來一起學習學習吧。
    2017-10-10
  • 阿里云CentOS 7系統(tǒng)掛載SSD云盤的教程

    阿里云CentOS 7系統(tǒng)掛載SSD云盤的教程

    最近在阿里云購買了塊云盤,但悲催的發(fā)現(xiàn)阿里云購買的第2塊云盤默認是不自動掛載的,需要手動配置掛載上。所以只能求助萬能的百度了,通過查找網(wǎng)上的資料,和自己的實踐終于將云盤掛載成功了,現(xiàn)在將步驟分享給大家,有同樣需要的朋友們可以參考借鑒。
    2016-11-11
  • 詳解linux下mnt目錄作用

    詳解linux下mnt目錄作用

    本篇文章主要介紹了linux下mnt目錄作用,詳細的介紹了Mount命令,具有一定的參考價值,有興趣的可以了解一下。
    2016-12-12
  • Linux中Homebrew的正確使用方法

    Linux中Homebrew的正確使用方法

    這篇文章主要給大家介紹了關(guān)于Linux中Homebrew的正確使用方法,文中通過示例代碼介紹的非常詳細,對大家學習或者使用Linux系統(tǒng)具有一定的參考學習價值,需要的朋友們下面來一起學習學習吧
    2019-09-09
  • linux實現(xiàn)猜數(shù)字小游戲源碼

    linux實現(xiàn)猜數(shù)字小游戲源碼

    這篇文章主要為大家詳細介紹了linux實現(xiàn)猜數(shù)字小游戲源碼,文中示例代碼介紹的非常詳細,具有一定的參考價值,感興趣的小伙伴們可以參考一下
    2020-04-04
  • CentOS 8 正式發(fā)布

    CentOS 8 正式發(fā)布

    CentOS 8 和RedHat Enterprise Linux 8發(fā)行的版本是一致的,都是基于 Fedora 28 和 內(nèi)核 4.18.支持傳統(tǒng)的、新興的工作負載的工具,為用戶提供了穩(wěn)定的、安全的、一致的基礎(chǔ)、跨混合云部署
    2019-09-09
  • Apache上部署Django步驟詳細介紹

    Apache上部署Django步驟詳細介紹

    這篇文章主要介紹了Apache上部署Django步驟詳細介紹的相關(guān)資料,需要的朋友可以參考下
    2017-02-02
  • linux安裝RocketMQ實例步驟

    linux安裝RocketMQ實例步驟

    在本篇文章里小編給大家整理的是關(guān)于linux安裝RocketMQ實例步驟內(nèi)容,需要的朋友們可以參考下。
    2020-02-02
  • Apache負載均衡設(shè)置方法 mod_proxy使用介紹

    Apache負載均衡設(shè)置方法 mod_proxy使用介紹

    本文主要講解了Apache負載均衡功能的代碼配置,首先我們通過幾個模塊的功能進行配置,之后就會發(fā)現(xiàn)其中的奧秘了,那么我們還是來具體看文章吧
    2012-10-10

最新評論