中南大学2021级云计算复习笔记

选择题 20分 10个

填空题 10分 10个

判断题 10分 5个

简答题 20分 4个

编程题 40分 2个

云计算基础

云计算的概念：云计算是一种商业计算模型。它将计算任务分布在大量计算机构成的资源池上，使各种应用系统能够根据需要获取计算力、存储空间和信息服务。

云计算是并行计算、分布式计算和网格计算的发展，或者说是这些计算机科学概念的商业实现

并行计算：同时使用多种计算资源解决计算问题的过程
分布式计算：将需要巨大计算能力的问题分成许多小部分进行处理，最后综合结果
网格计算：在动态、多机构参与的虚拟组织中协同共享资源和求解问题

云计算是虚拟化、效用计算、IaaS、PaaS、SaaS等技术混合演进、提升的结果

云计算主要管理计算资源、存储资源、网络资源三个方面

云计算特点：超大规模、虚拟化、高可靠性、通用性、高可伸缩性、按需服务、极其廉价

云计算服务类型：

IaaS（将基础设施作为服务）：将硬件设备等基础资源封装成服务供用户使用
PaaS（将平台作为服务）：对资源的抽象层次更进一步，提供用户应用程序运行环境
SaaS（将软件作为服务）：针对性更强，它将某些特定应用软件功能封装成服务

云计算架构

云计算分为前端和后端两个部分：

前端：指用户的计算机或客户端，包括用户计算机（或计算机网络）以及云计算系统登录程序。不同的云计算系统具有不用的用户界面。
后端：各种各样的计算机、服务器和数据存储系统，它们共同组成了云计算系统中的“云”。
二者通过网络相互连接。

架构图：

1d0a5ad4361dad7f1c38170877027bff

SOA构建层：封装云计算能力成标准的web services服务，并纳入SOA体系
管理中间件层：云计算的资源管理，并对众多应用任务进行调度，使资源能够高效、安全地为应用提供服务
资源池层：将大量相同类型的资源构成同构或接近同构的资源池
物理资源层：计算机、存储器、网络设施、数据库和软件等

云计算和网格计算的关系：

01652222ebc16275467484e55d13bf2d

为什么云计算成本很低？

主要原因是云计算的技术特征和规模效应所带来的压倒性的性能价格比优势。

云计算有更低的硬件和网络成本、更低管理成本和电力成本，也有更高的资源利用率。两个乘起来能够将成本节省30倍以上。

515dc03b6fd38063afa0f5c4bb3fd7f6

大数据及特点

大数据的定义：海量数据或巨量数据，其规模巨大到无法通过目前主流的计算机系统在合理时间内获取、存储、管理、处理并提炼以帮助使用者决策。

大数据特点：价值密度低、快速、复杂度、数据量大、多样

大数据、云计算、人工智能是什么关系（一定要掌握）

45562e2f93a0bd424711e0e3072d7100

x是大数据，f是人工智能和云计算，G是我们的目标。也就是说，云计算和人工智能是处理大数据的手段，我们通过人工智能技术和云计算技术去处理大数据，来达成我们的目标。大数据与人工智能和云计算是一枚硬币的正反面。大数据是需求，云计算和人工智能是手段。没有大数据就不需要人工智能和云计算。没有人工智能和云计算，就无法处理大数据。

谷歌的云计算的核心技术

三个技术：MapReduce, GFS, BigTable

谷歌的分布式文件系统怎么设计

Google GFS的新颖之处在于它采用廉价的商用及其构建分布式文件系统，同时将GFS的设计与Google应用的特点紧密结合，简化实现，使之可行，最终达到创意新颖、有用、可行的完美组合。

GFS将容错的任务交给文件系统完成，利用软件的方法解决系统可靠性问题，是存储的成本成倍下降。GFS将服务器故障视为正常现象，并采用多种方法，从多个角度，使用不同的容错措施，确保数据存储的安全、保证提供不间断的数据存储服务。

GFS架构

eac763ce82556f3ca4ee016bedf5279e

GFS将整个系统节点分为三类角色：

GFS的实现机制

客户端首先访问Master节点，获取交互的Chunk Server信息，然后访问这些Chunk Server，完成数据存取工作。这种设计方式实现了控制流和数据流的分离。
Client与Master之间只有控制流，而无数据流，极大地降低了Master的负载。
Client与Chunk Server之间直接传输数据流，同时由于文件被分为多个Chunk进行分布式存储，Client可以同时访问多个Chunk Server，从而使得整个系统的I/O高度并行，系统整体性能得到提高。

GFS容错机制

Master容错

Master上保存了GFS文件系统的三种元数据：

首先就单个Master来说，对于前两种数据，GFS通过操作日志来提供容错功能。第三种元数据信息则直接保存再各个Chunk Server上，当Master启动或Chunk Server向Master注册时自动生成。

当Master发生故障时，在磁盘数据保存完好的情况下，可以迅速恢复以上元数据。为了防止Master彻底死机的情况，GFS还提供了Master远程的实时备份，这样在当前的GFS Master出现故障无法工作的时候，另外一台GFS Master可以迅速接替其工作。

Chunk Server容错

GFS采用副本的方式实现Chunk Server的容错
每一个Chunk有多个存储副本（默认为三个）
对于每一个Chunk，必须将所有的副本全部写入成功，才视为成功写入
相关的副本出现丢失或不可恢复等情况，Master自动将该副本复制到其他的Chunk Server

MapReduce （会编程）

MapReduce是Google提出的一个软件架构，是一种处理海量数据的并行编程模式，用于大规模数据集（通常大于1TB）的并行计算。

MapReduce封装了并行处理、容错处理、本地化计算、负载均衡等细节，还提供了一个简单而强大的接口。通过这个接口，可以把大尺度的计算自动地并发和分布执行，是编程变得非常容易。

MapReduce把对数据集的大规模操作，分发给一个主节点管理下的各分节点共同完成，通过这种方式实现任务的可靠执行与容错机制。

MapReduce编程模型

Map函数——对一部分原始数据进行指定的操作。每个Map操作都针对不同的原始数据，因此Map与Map之间是互相独立的，这使得它们可以充分并行化。

Reduce操作——对每个Map所产生的一部分中间结果进行合并操作，每个Reduce所处理的Map中间结果是互不交叉的，所有Reduce产生的最终结果经过简单连接就形成了完整的结果集.

Map输入参数：in_key和in_value，它指明了Map需要处理的原始数据

Map输出结果：一组<key,value>对，这是经过Map操作后所产生的中间结果

Reduce输入参数：（key,[ $value_1$ ,…, $value_m$ ]）

Reduce工作：对这些对应相同key的value值进行归并处理

Reduce输出结果：（key, final_value），所有Reduce的结果并在一起就是最终结果

MapReduce操作的执行流程

Master容错

Master会周期性地设置检查点（checkpoint），并导出Master的数据。一旦某个任务失效，系统就从最近的一个检查点恢复并重新执行。由于只有一个Master在运行，如果Master失效了，则只能终止整个MapReduce程序的运行并重新开始。

Worker容错：

Master会周期性地给Worker发送ping命令，如果没有Worker的应答，则Master认为Worker失效，终止对这个Worker的任务调度，把失效Worker的任务调度到其他Worker上重新执行。

分布式锁服务Chubby

Chubby是Google设计的提供粗粒度锁服务的一个文件系统，它基于松耦合分布式系统，解决了分布的一致性问题。

Paxos算法（一定要掌握）

系统约束条件

p1：每个acceptor只接受它得到的第一个决议。
p2：一旦某个决议得到通过，之后通过的决议必须和该决议保持一致。
- p2a：一旦某个决议v得到通过，之后任何acceptor再批准的决议必须是v。
- p2b：一旦某个决议v得到通过，之后任何proposer再提出的决议必须是v。
- p2c：如果一个编号为n的提案具有值v，那么存在一个“多数派”，要么它们中没有谁批准过编号小于n的任何提案，要么它们进行的最近一次批准具有值v。

为了保证决议的唯一性，acceptors也要满足一个约束条件：当且仅当 acceptors 没有收到编号大于n的请求时，acceptors 才批准编号为n的提案。

Chubby设计目标

高可用性和高可靠性、高扩展性、支持粗粒度的建议性锁服务、服务信息的直接存储、支持缓存机制、支持通报机制。

Bigtable数据存储格式

Bigtable是一个分布式多维映射表，表中的数据通过一个行关键字（Row Key）、一个列关键字（Column Key）以及一个时间戳（Time Stamp）进行索引。

Bigtable的存储逻辑可以表示为：(row:string, column:string, time:int64)→string

Megatstore

nosql优点缺点（一定要掌握）

优点：

Cheap（廉价）
Scalable（可扩展）
Handles large data（可处理大批数据）

缺点：

Inconsistent APIs（API前后不一致）
Lack of complicated queries requires joins / aggregations / filters（缺少复杂的查询请求：连接/聚合/过滤器）
Lack of ACID（缺少事务的原子性、一致性、隔离性、持久性）

Megastore索引

Megastore提供的三种读

Megastore完整的事务周期

Megastore三种副本

Dapper两个基本要求

广泛可部署性：设计出的监控系统应当能够对尽可能多的Google服务进行监控
不间断的监控：Google的服务是全天候的，如果不能对Google的后台同样进行全天候的监控很可能会错过某些无法再现的关键性故障

Dapper三个基本设计目标

低开销：这个是广泛可部署性的必然要求。监控系统的开销越低，对于原系统的影响就越小，系统的开发人员也就越愿意接受这个监控系统。
对应用层透明：监控系统对程序员应当是不可见的。如果监控系统的使用需要程序开发人员对其底层的一些细节进行调整才能正常工作的话，这个监控系统肯定不是一个完整的监控系统。
可扩展性：Google的服务增长速度是惊人的，设计出的系统至少在未来几年里要能够满足Google服务和集群的需求。

Dapper监控系统的三个基本概念

监控树（Trace Tree）：一个同特定事件相关的所有消息
区间（Span）：区间实际上就是一条记录
注释（Annotation）：注释主要用来辅助推断区间关系，也可以包含一些自定义的内容

Dapper关键技术：

轻量级核心功能库：

二次抽样技术

利用二次抽样技术成功地解决了低开销及广泛可部署性的问题。

第一次抽样：实践中，设计人员发现当抽样率低至1/1024时也能够产生足够多的有效监控数据，即在1024个请求中抽取1个进行监控也是可行的，从而可以捕获有效数据。
第二次抽样：发生在数据写入Bigtable前，具体方法是将监控id散列成一个标量z(0 <= z <= 1)，如果某个区间的z小于事先定义好的汇总抽样系数，则保留这个区间并将它写入Bigtable，否则丢弃

Google App Engine

Google App Engine是一个由Python应用服务器群、Bigtable数据库及GFS数据存储服务组成的平台，它能为开发者提供一体化的可自动升级的在线应用服务。

沙盒的限制

用户的应用程序只能通过GAE提供的网址抓取API和电子邮件服务API来访问互联网中其他的计算机，其他计算机如请求与该应用相连接，只能在标准接口上通过HTTP或HTTPS进行
应用程序无法对GAE的文件系统进行写入操作，只能读取应用程序代码上的文件，并且该应用程序必须使用GAE的Data Store数据库来存储应用程序运行期间持续存在的数据
应用程序只有在响应网络请求时才运行，并且这个响应实践必须极短，在几秒之内必须完成。与此同时，请求处理的程序不能在自己的响应发送后产生子进程或执行代码

亚马逊基础存储架构Dynamo

数据均衡分布（一定要掌握）

采取了改进的一致性哈希算法

一致性哈希算法是目前主流的分布式哈希表（Distributed Hash Table, DHT）协议之一，通过修正简单哈希算法，解决了网络中的热点问题，使DHT可以真正地应用于P2P环境中。

一致性哈希算法除了能够保证哈希运算结果充分分散到整个环上外，还能保证在添加或删除设备节点时只会影响到其在哈希环中的前驱设备节点，而不会对其他设备节点产生影响。

一致性哈希算法可以大大降低在添加或删除节点时引起的节点间的数据传输开销

改进的一致性哈希算法

Dynamo中引入了虚拟节点的概念，每个虚拟节点抖隶属于一个实际的物理节点，一个物理节点根据其性能的差异被分为一个或多个虚拟节点

各个虚拟节点的能力基本相当，并随机分布在哈希环上

Dynamo将整个哈希环划分为Q等份，每个等份称为一个数据分区（Partition）

在存储数据时，每个数据会被先分配到某个数据分区，再根据负责该数据分区的虚拟节点，最终确定其所存储的物理节点。

数据分区的好处：

建小数据分布不均衡的可能性
添加或删除设备节点时引起较小的数据传输

数据备份

数据冲突问题

成员资格及错误检测

容错机制

临时故障处理机制

永久性故障处理机制

弹性计算云EC2

机器映像

实例

地理区域，可用区域

EC2系统中包含多个地理区域，而每个地理区域中又包含多个可以区域。为了确保系统的稳定性，用户最好将自己的多个实例分布再不同的可用区域和地理区域中。

三种ip

hadoop

两个编程题搞清楚

一个是用MR编程做图书统计，排序

Mapper类：

public class BookCountMapper extends Mapper<Object, Text, Text, IntWritable> {

    private Text bookTitle = new Text();
    private IntWritable count = new IntWritable();

    public void map(Object key, Text value, Context context)
            throws IOException, InterruptedException {
        // 假设输入格式为 "书名  数量"
        String[] parts = value.toString().split("\\s+");

        if (parts.length == 2) {
            // 提取书名和数量
            String title = parts[0];
            int quantity = Integer.parseInt(parts[1]);

            // 输出键值对 (书名, 数量)
            bookTitle.set(title);
            count.set(quantity);
            context.write(bookTitle, count);
        }
    }
}

Reducer类：

public class BookCountReducer extends Reducer<Text, IntWritable, Text, IntWritable> {

    private IntWritable result = new IntWritable();

    public void reduce(Text key, Iterable<IntWritable> values, Context context)
            throws IOException, InterruptedException {
        int sum = 0;
        for (IntWritable value : values) {
            sum += value.get();
        }
        result.set(sum);
        context.write(result, key);
    }
}

主程序：

public class BookCount {

    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf, "BookCount");

        job.setJarByClass(BookCount.class);
        job.setMapperClass(BookCountMapper.class);
        job.setReducerClass(BookCountReducer.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        job.setInputFormatClass(TextInputFormat.class);
        job.setOutputFormatClass(TextOutputFormat.class);

        TextInputFormat.addInputPath(job, new Path(args[0])); // 输入路径1
        TextInputFormat.addInputPath(job, new Path(args[1])); // 输入路径2
        TextOutputFormat.setOutputPath(job, new Path(args[2])); // 输出路径

        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

一个是spark编程，实验的两个例子

wordcount

import org.apache.spark.{SparkConf, SparkContext}

object WordCount {
  def main(args: Array[String]): Unit = {
    // 创建Spark配置
    val conf = new SparkConf().setAppName("WordCount")
    // 创建Spark上下文
    val sc = new SparkContext(conf)

    // 读取输入数据，这里假设输入数据是一个文本文件
    val input = sc.textFile("input.txt")

    // 执行WordCount操作
    val wordCounts = input
      .flatMap(line => line.split(" ")) // 将每行文本拆分为单词
      .map(word => (word, 1))           // 将每个单词映射为 (单词, 1) 键值对
      .reduceByKey(_ + _)               // 按键合并相同单词的计数
      .sortByKey()                      // 按单词排序

    // 打印结果
    wordCounts.collect().foreach(println)

    // 关闭Spark上下文
    sc.stop()
  }
}

pagerank

import org.apache.spark.{SparkConf, SparkContext}

object PageRank {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf().setAppName("PageRank")
    val sc = new SparkContext(conf)

    // 从文件中读取初始图数据，每行格式为：source_node target_node
    val links = sc.textFile("input.txt").map(line => {
      val parts = line.split("\\s+")
      (parts(0), parts(1))
    }).distinct().groupByKey().cache()

    // 初始化每个节点的PageRank值为1.0
    var ranks = links.mapValues(_ => 1.0)

    // 迭代计算PageRank值
    for (i <- 1 to 10) {
      val contributions = links.join(ranks).flatMap {
        case (node, (neighbors, rank)) =>
          neighbors.map(neighbor => (neighbor, rank / neighbors.size))
      }
      ranks = contributions.reduceByKey(_ + _).mapValues(0.15 + 0.85 * _)
    }

    // 打印最终的PageRank值
    val result = ranks.collect()
    result.foreach(println)

    sc.stop()
  }
}