- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

大数据物流项目：Kudu 操作命令（五.五）

Maynor学长发表于 2022/06/21 20:55:51 2022/06/21

【摘要】 11-[掌握]-Java 操作 Kudu之创建表(范围分区)为了提供可扩展性，Kudu 表被划分为称为 tablets 的单元，并分布在许多 tablet servers 上。1）、哈希分区：Hash Partitioning哈希分区通过哈希值，将行分配到不同的 buckets ( 存储桶 )中；哈希分区是一种有效的策略，当不需要对表进行有序访问时，哈希分区对于在 tablet 之间随机散...

11-[掌握]-Java 操作 Kudu之创建表(范围分区)

为了提供可扩展性，Kudu 表被划分为称为 tablets 的单元，并分布在许多 tablet servers 上。

1）、哈希分区：Hash Partitioning

哈希分区通过哈希值，将行分配到不同的 buckets ( 存储桶 )中；

哈希分区是一种有效的策略，当不需要对表进行有序访问时，哈希分区对于在 tablet 之间随
机散布这些功能是有效的，这有助于减轻热点和 tablet 大小不均匀；

2）、范围分区：Range Partitioning

范围分区可根据存入数据的数据量，均衡的存储到各个机器上，防止机器出现负载不均衡现象；

分区键必须是主键或主键的一部分；

Range分区的方式：id

实现上述案例需求：创建Kudu表，按照id进行范围分区

	/**
	 * 创建Kudu中的表，采用对id进行Range范围分区
	 */
	@Test
	public void createKuduTableByRange() throws KuduException {
		// a. 定义Schema信息，列名称和列类型
		List<ColumnSchema> columns = new ArrayList<>();
		columns.add(new ColumnSchema.ColumnSchemaBuilder("id", Type.INT32).key(true).build());
		columns.add(newColumnSchema("name", Type.STRING, false));
		columns.add(newColumnSchema("age", Type.INT8, false));
		Schema schema = new Schema(columns) ;

		// b. 设置表的属性
		CreateTableOptions options = new CreateTableOptions() ;
		// 设置分区策略
		options.setRangePartitionColumns(Arrays.asList("id")); // 设置范围分区字段名称
		/*
			id < 100
			100 <= id < 500
			id > 500
		 */
		// id < 100
		PartialRow upper100 = new PartialRow(schema);
		upper100.addInt("id", 100);
		options.addRangePartition(new PartialRow(schema), upper100);

		// 100 <= id < 500 
		PartialRow lower100 = new PartialRow(schema);
		lower100.addInt("id", 100);
		PartialRow upper500 = new PartialRow(schema);
		upper500.addInt("id", 500);
		options.addRangePartition(lower100, upper500);

		// id > 500
		PartialRow lower500 = new PartialRow(schema);
		lower500.addInt("id", 500);
		options.addRangePartition(lower500, new PartialRow(schema));

		// 设置副本数目
		options.setNumReplicas(1) ;

		// c. 传递参数，创建表
		/*
			public KuduTable createTable(String name, Schema schema, CreateTableOptions builder)
		 */
		KuduTable kuduTable = kuduClient.createTable("itcast_users_range", schema, options);
		System.out.println("Kudu Table ID = " + kuduTable.getTableId());
	}

12-[掌握]-Java 操作 Kudu之创建表(多级分区)

在Kudu中，创建表时，除了Hash分区和Range范围分区以外，还支持多级分区：

1）、形式一、==先哈希分区，再进行范围分区==

2）、形式二、==先哈希分区，再哈希分区==

多级分区特点：

Kudu 允许一个表上组合使用Hash分区及 Range分区；

分区键必须是主键或主键的一部分；

多级分区可以保留各个分区类型的优点，同时减少每个分区的缺点；

创建表，实现上述表分区要求：==先按照id进行哈希分区，再按照age做范围分区==

	/**
	 * 创建Kudu中的表，采用多级分区策略，结合哈希分区和范围分区组合使用
	 */
	@Test
	public void createKuduTableMulti() throws KuduException {
		// a. 构建表的Schema信息
		List<ColumnSchema> columnSchemas = new ArrayList<ColumnSchema>();
		columnSchemas.add(newColumnSchema("id", Type.INT32, true)) ;
		columnSchemas.add(newColumnSchema("age", Type.INT8, true)) ;
		columnSchemas.add(newColumnSchema("name", Type.STRING, false)) ;
		// 定义Schema信息
		Schema schema = new Schema(columnSchemas) ;
		
		// b. Kudu表的分区策略及分区副本数目设置
		CreateTableOptions tableOptions = new CreateTableOptions() ;
		// TODO： e.1. 设置哈希分区
		List<String> columnsHash = new ArrayList<>() ;
		columnsHash.add("id") ;
		tableOptions.addHashPartitions(columnsHash, 5) ;
		
		// TODO: e.2. 设值范围分区
		/*
			age 做 range分区，分3个区
			- < 21（小于等于20岁）
			- 21 - 41（21岁到40岁）
			- 41（41岁以上，涵盖41岁）
		*/
		List<String> columnsRange = new ArrayList<>() ;
		columnsRange.add("age") ;
		tableOptions.setRangePartitionColumns(columnsRange) ;
		// 添加范围分区
		PartialRow upper21 = new PartialRow(schema) ;
		upper21.addByte("age", (byte)21);
		tableOptions.addRangePartition(new PartialRow(schema), upper21) ;
		// 添加范围分区
		PartialRow lower21 = new PartialRow(schema) ;
		lower21.addByte("age", (byte)21);
		PartialRow upper41 = new PartialRow(schema) ;
		upper41.addByte("age", (byte)41);
		tableOptions.addRangePartition(lower21, upper41) ;
		// 添加范围分区
		PartialRow lower41 = new PartialRow(schema) ;
		lower41.addByte("age", (byte)41);
		tableOptions.addRangePartition(lower41, new PartialRow(schema)) ;
		
		// 副本数设置
		tableOptions.setNumReplicas(1) ;
		
		// c. 在Kudu中创建表
		KuduTable userTable = kuduClient.createTable("itcast_users_multi", schema, tableOptions);
		System.out.println(userTable.toString());
	}

13-[掌握]-Java 操作 Kudu之添加列和删除列

任务：==对Kudu中表进行修改，要么表添加列，要么表删除列==，编程演示代码

1）、添加列addColumn

	/**
	 * 对Kudu中表进行修改，增加列：address，String
	 */
	@Test
	public void alterKuduTableAddColumn() throws KuduException {
		// 添加列
		AlterTableOptions ato = new AlterTableOptions() ;
		ato.addColumn("address",Type.STRING, "shanghai");
		// 修改表
		AlterTableResponse response = kuduClient.alterTable("itcast_users", ato);
		System.out.println(response.getTableId());
	}

2）、删除列dropColumn

	/**
	 * 对Kudu中表进行修改，删除列：address
	 */
	@Test
	public void alterKuduTableDropColumn() throws KuduException {
		// 添加列
		AlterTableOptions ato = new AlterTableOptions() ;
		ato.dropColumn("address");
		// 修改表
		AlterTableResponse response = kuduClient.alterTable("itcast_users", ato);
		System.out.println(response.getTableId());
	}

14-[掌握]-Kudu 集成 Spark之创建Maven Project

Kudu支持与Spark集成，并且提供集成库jar包，直接引入库，调用API即可，提供2套API：

1）、第一套：基于RDD数据集操作，KuduContext上下文对象

DDL操作，创建Kudu表和删除Kudu表

2）、第二套：基于DataFrame数据集操作，SparkSession会话对象

从Kudu表中加载load和保存save数据

==首先，创建Maven Module模块，添加相关依赖，创建包，如下所示：==

构建Maven Project工程或Maven Module模块，POM文件添加依赖如下：

    <!-- 指定仓库位置，依次为aliyun、cloudera和jboss仓库 -->
    <repositories>
        <repository>
            <id>aliyun</id>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        </repository>
        <repository>
            <id>cloudera</id>
            <url>https://repository.cloudera.com/artifactory/cloudera-repos/</url>
        </repository>
        <repository>
            <id>jboss</id>
            <url>http://repository.jboss.com/nexus/content/groups/public</url>
        </repository>
    </repositories>

    <!-- 版本属性 -->
    <properties>
        <scala.version>2.11.12</scala.version>
        <scala.binary.version>2.11</scala.binary.version>
        <spark.version>2.4.0-cdh6.2.1</spark.version>
        <hadoop.version>3.0.0-cdh6.2.1</hadoop.version>
        <kudu.version>1.9.0-cdh6.2.1</kudu.version>
    </properties>

    <!-- 依赖JAR包 -->
    <dependencies>

        <dependency>
            <groupId>org.apache.kudu</groupId>
            <artifactId>kudu-client-tools</artifactId>
            <version>${kudu.version}</version>
        </dependency>

        <!-- Kudu Client 依赖包 -->
        <dependency>
            <groupId>org.apache.kudu</groupId>
            <artifactId>kudu-client</artifactId>
            <version>${kudu.version}</version>
        </dependency>

        <!-- Junit 依赖包 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.apache.kudu/kudu-spark2 -->
        <dependency>
            <groupId>org.apache.kudu</groupId>
            <artifactId>kudu-spark2_2.11</artifactId>
            <version>${kudu.version}</version>
        </dependency>

        <!-- 依赖Scala语言 -->
        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>

        <!-- Spark Core 依赖 -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-core_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <!-- Spark SQL 依赖 -->
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_${scala.binary.version}</artifactId>
            <version>${spark.version}</version>
        </dependency>

        <!-- Hadoop Client 依赖 -->
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-client</artifactId>
            <version>${hadoop.version}</version>
        </dependency>

    </dependencies>

    <build>
        <outputDirectory>target/classes</outputDirectory>
        <testOutputDirectory>target/test-classes</testOutputDirectory>
        <resources>
            <resource>
                <directory>${project.basedir}/src/main/resources</directory>
            </resource>
        </resources>
        <!-- Maven 编译的插件 -->
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>net.alchim31.maven</groupId>
                <artifactId>scala-maven-plugin</artifactId>
                <version>3.2.0</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

编写Spark Application时，设置日志级别，通过log4j.properties设置，内容如下所示：

# Set everything to be logged to the console
log4j.rootCategory=WARN, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n

# Set the default spark-shell log level to WARN. When running the spark-shell, the
# log level for this class is used to overwrite the root logger's log level, so that
# the user can have different defaults for the shell and regular Spark apps.
log4j.logger.org.apache.spark.repl.Main=WARN

# Settings to quiet third party logs that are too verbose
log4j.logger.org.spark_project.jetty=WARN
log4j.logger.org.spark_project.jetty.util.component.AbstractLifeCycle=ERROR
log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=INFO
log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=INFO
log4j.logger.org.apache.parquet=ERROR
log4j.logger.parquet=ERROR

# SPARK-9183: Settings to avoid annoying messages when looking up nonexistent UDFs in SparkSQL with Hive support
log4j.logger.org.apache.hadoop.hive.metastore.RetryingHMSHandler=FATAL
log4j.logger.org.apache.hadoop.hive.ql.exec.FunctionRegistry=ERROR

spark-shell时，可以通过--packages或--jars加载依赖jar包：
1）、--packages
	--packages org.apache.kudu:kudu-spark_2.10:1.5.0
	必须联网，基于ivy方式下载所需要的jar包，存储在当前用户宿主目录下$USER_HOME/.ivy/jars/

2）、--jars
	--jars /root/jars/xxx.jar,/root/jars/yy.jar 
	需要将jar包下载完成，放在本地，加载到应用中

15-[掌握]-Kudu 集成 Spark之创建表和删除表

任务：==使用KuduContext创建Kudu表和删除Kudu表==

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M2fLWMra-1625969711974)(/img/1615885235177.png)]

package cn.itcast.kudu.table

import java.util

import org.apache.kudu.client.CreateTableOptions
import org.apache.kudu.spark.kudu.KuduContext
import org.apache.spark.sql.SparkSession
import org.apache.spark.sql.functions._
import org.apache.spark.sql.types.{IntegerType, StringType, StructField, StructType}

/**
 * Kudu与Spark集成，使用KuduContext创建表和删除表
 */
object KuduSparkTableDemo {
	
	/**
	 * 创建Kudu表，指定名称
	 *
	 * @param tableName 表的名称
	 * @param kuduContext KuduContext实例对象
	 */
	def createKuduTable(tableName: String, kuduContext: KuduContext): Unit = {
		// a. 表的Schema信息
		val schema: StructType = StructType(
			Array(
				StructField("id", IntegerType, nullable = false),
				StructField("name", StringType, nullable = true),
				StructField("age", IntegerType, nullable = true),
				StructField("gender", StringType, nullable = true)
			)
		)
		// b. 表的主键
		val keys: Seq[String] = Seq("id")
		// c. 创建表的选项设置
		val options: CreateTableOptions = new CreateTableOptions()
		options.setNumReplicas(1)
		options.addHashPartitions(util.Arrays.asList("id"), 3)
		// 调用创建表方法
		/*
		  def createTable(
		      tableName: String,
		      schema: StructType,
		      keys: Seq[String],
		      options: CreateTableOptions
		  ): KuduTable
		 */
		val kuduTable = kuduContext.createTable(tableName, schema, keys, options)
		println("Kudu Table ID: " + kuduTable)
	}
	
	/**
	 * 删除Kudu中表
	 * @param tableName 表的名称
	 * @param kuduContext KuduContext实例对象
	 */
	def dropKuduTable(tableName: String, kuduContext: KuduContext) = {
		// 判断表是否存在，如果存在，就删除表
		if(kuduContext.tableExists(tableName)){
			kuduContext.deleteTable(tableName)
		}
	}
	
	def main(args: Array[String]): Unit = {
		// 1. 构建SparkSession实例对象
		val spark: SparkSession = SparkSession.builder()
    		.appName(this.getClass.getSimpleName.stripSuffix("$"))
    		.master("local[2]")
    		.config("spark.sql.shuffle.partitions", "2")
    		.getOrCreate()
		import spark.implicits._
		
		// TODO: 创建KuduContext对象
		val kuduContext: KuduContext = new KuduContext("node2.itcast.cn:7051", spark.sparkContext)
		println(s"KuduContext: ${kuduContext}")
		
		// 任务1： 创建表
		//createKuduTable("kudu_itcast_users", kuduContext)
		
		// 任务2： 删除表
		dropKuduTable("kudu_itcast_users", kuduContext)
		
		
		// 应用结束，关闭资源
		spark.stop()
	}
	
}

注意：在创建表时，主键不能为null，必须设置为false，字段放在最前面。

16-[理解]-Kudu 集成 Spark之数据CRUD操作

任务：编写程序，对Kudu表的数据，进行CRUD操作，==与Java Client API类似==。

1）、Insert插入数据、INSERT-IGNORE 如果存在，忽略

2）、DELETE删除数据

3）、UPDATE更新数据

4）、UPSERT插入更新数据，主键不存在就是插入，存在就是更新

1）、插入数据insert

package cn.itcast.kudu.data

import cn.itcast.kudu.table.KuduSparkTableDemo.createKuduTable
import org.apache.kudu.spark.kudu.KuduContext
import org.apache.spark.sql.{DataFrame, SparkSession}

/**
 * 对Kudu表的数据，进行CRUD操作
 */
object KuduSparkDataDemo {
	
	/**
	 * 向Kudu表中插入数据
	 */
	def insertData(spark: SparkSession, kuduContext: KuduContext, tableName: String): Unit = {
		// a. 模拟产生数据
		// TODO: 当RDD或Seq中数据类型为元组时，直接调用toDF，指定列名称，转换为DataFrame
		val usersDF: DataFrame = spark.createDataFrame(
			Seq(
				(1001, "zhangsan", 23, "男"),
				(1002, "lisi", 22, "男"),
				(1003, "xiaohong", 24, "女"),
				(1004, "zhaoliu2", 33, "男")
			)
		).toDF("id", "name", "age", "gender")
		
		// b. 将数据保存至Kudu表
		kuduContext.insertRows(usersDF, tableName)
	}
	
	def main(args: Array[String]): Unit = {
		// 1. 构建SparkSession实例对象
		val spark: SparkSession = SparkSession.builder()
			.appName(this.getClass.getSimpleName.stripSuffix("$"))
			.master("local[2]")
			.config("spark.sql.shuffle.partitions", "2")
			.getOrCreate()
		import spark.implicits._
		
		// TODO: 创建KuduContext对象
		val kuduContext: KuduContext = new KuduContext("node2.itcast.cn:7051", spark.sparkContext)
		//println(s"KuduContext: ${kuduContext}")
		
		val tableName = "kudu_itcast_users"
		
		// 插入数据
		insertData(spark, kuduContext, tableName)
		
		// 查询数据
		//selectData(spark, kuduContext, tableName)
		
		// 更新数据
		//updateData(spark, kuduContext, tableName)
		
		// 插入更新数据
		//upsertData(spark, kuduContext, tableName)
		
		// 删除数据
		//deleteData(spark, kuduContext, tableName)
		
		
		// 应用结束，关闭资源
		spark.stop()
	}
	
}

2）、查询数据，将数据封装到RDD数据集

	/**
	 * 从Kudu表中读取数据，封装到RDD数据集
	 */
	def selectData(spark: SparkSession, kuduContext: KuduContext, tableName: String): Unit = {
		/*
		  def kuduRDD(
		      sc: SparkContext,
		      tableName: String,
		      columnProjection: Seq[String] = Nil,
		      options: KuduReadOptions = KuduReadOptions()
		  ): RDD[Row]
		 */
		val kuduRDD: RDD[Row] = kuduContext.kuduRDD(spark.sparkContext, tableName, Seq("name", "age"))
		
		// 遍历数据
		kuduRDD.foreach{row =>
			println(
				"name = " + row.getString(0) + ", age = " + row.getInt(1)
			)
		}
	}

此外，可以使用KuduContext对表的数据进行update、upsert、delete等操作，类似insert操作。

17-[掌握]-Kudu 集成 Spark之DataFrame API

任务：基于SparkSQL提供外部数据源方式从Kudu数据库中加载load和保存save数据，封装DataFrame中。

==从Kudu表加载和保存数据数据时，可选项如下所示：==

编写SparkSQL程序，从Kudu表加载load数据，进行转换，最终保存到Kudu表中。

1）、加载数据

		// TODO: 2. 从Kudu表加载数据
		val kuduDF: DataFrame = spark.read
			.format("kudu")
			.option("kudu.table", "kudu_itcast_users")
			.option("kudu.master", "node2.itcast.cn:7051")
			.load()
		kuduDF.printSchema()
		kuduDF.show(10, truncate = false)

2）、保存数据

		// TODO: 保存数据到Kudu表
		etlDF.write
			.mode(SaveMode.Append)
			.format("kudu")
			.option("kudu.table", "kudu_itcast_users")
			.option("kudu.master", "node2.itcast.cn:7051")
			.option("kudu.operation", "upsert")
			.save()

完整代码：从Kudu表读取数据，经过ETL转换，保存到Kudu表

package cn.itcast.kudu.sql

import org.apache.spark.sql.expressions.UserDefinedFunction
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}
import org.apache.spark.sql.functions._

/**
 * 编写SparkSQL程序，从Kudu表加载load数据，进行转换，最终保存到Kudu表中。
 */
object KuduSparkSQLDemo {
	
	def main(args: Array[String]): Unit = {
		// 1. 构建SparkSession实例对象
		val spark: SparkSession = SparkSession.builder()
			.appName(this.getClass.getSimpleName.stripSuffix("$"))
			.master("local[2]")
			.config("spark.sql.shuffle.partitions", "2")
			.getOrCreate()
		import spark.implicits._
		
		// TODO: 2. 从Kudu表加载数据
		val kuduDF: DataFrame = spark.read
			.format("kudu")
			.option("kudu.table", "kudu_itcast_users")
			.option("kudu.master", "node2.itcast.cn:7051")
			.load()
		//kuduDF.printSchema()
		//kuduDF.show(10, truncate = false)
		
		/*
			+----+--------+---+------+
			|id  |name    |age|gender|
			+----+--------+---+------+
			|1001|zhangsan|23 |男    |  -> M
			|1002|lisi    |22 |男    |
			|1004|zhaoliu2|33 |男    |
			|1003|xiaohong|24 |女    |  -> F
			+----+--------+---+------+
		 */
		// 自定义UDF函数，转换gender性别
		val gender_to_udf: UserDefinedFunction = udf(
			(gender: String) => {
				gender match {
					case "男" => "M"
					case "女" => "F"
					case _ => "M"
				}
			}
		)
		
		// TODO： 调用UDF函数，进行转换
		val etlDF: DataFrame = kuduDF.select(
			$"id", $"name", //
			$"age".plus(1).as("age"),
			gender_to_udf($"gender").as("gender")
		)
		//etlDF.printSchema()
		//etlDF.show(10, truncate = false)
		
		// TODO: 保存数据到Kudu表
		etlDF.write
			.mode(SaveMode.Append)
			.format("kudu")
			.option("kudu.table", "kudu_itcast_users")
			.option("kudu.master", "node2.itcast.cn:7051")
			.option("kudu.operation", "upsert")
			.save()
			
		// 应用结束，关闭资源
		spark.stop()
	}
	
}



ocal[2]")
			.config("spark.sql.shuffle.partitions", "2")
			.getOrCreate()
		import spark.implicits._
		
		// TODO: 2. 从Kudu表加载数据
		val kuduDF: DataFrame = spark.read
			.format("kudu")
			.option("kudu.table", "kudu_itcast_users")
			.option("kudu.master", "node2.itcast.cn:7051")
			.load()
		//kuduDF.printSchema()
		//kuduDF.show(10, truncate = false)
		
		/*
			+----+--------+---+------+
			|id  |name    |age|gender|
			+----+--------+---+------+
			|1001|zhangsan|23 |男    |  -> M
			|1002|lisi    |22 |男    |
			|1004|zhaoliu2|33 |男    |
			|1003|xiaohong|24 |女    |  -> F
			+----+--------+---+------+
		 */
		// 自定义UDF函数，转换gender性别
		val gender_to_udf: UserDefinedFunction = udf(
			(gender: String) => {
				gender match {
					case "男" => "M"
					case "女" => "F"
					case _ => "M"
				}
			}
		)
		
		// TODO： 调用UDF函数，进行转换
		val etlDF: DataFrame = kuduDF.select(
			$"id", $"name", //
			$"age".plus(1).as("age"),
			gender_to_udf($"gender").as("gender")
		)
		//etlDF.printSchema()
		//etlDF.show(10, truncate = false)
		
		// TODO: 保存数据到Kudu表
		etlDF.write
			.mode(SaveMode.Append)
			.format("kudu")
			.option("kudu.table", "kudu_itcast_users")
			.option("kudu.master", "node2.itcast.cn:7051")
			.option("kudu.operation", "upsert")
			.save()
			
		// 应用结束，关闭资源
		spark.stop()
	}	
}

点赞
收藏
关注作者

0/1000

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

加入云驻计划，成为创作者

华为云周边好礼
免费体验产品
特殊身份标识
线下官方门票
内部专家零距离
与10000+优质创作者共同成长

立即加入