// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

[[release_notes]]
= Apache Kudu (incubating) Release Notes

:author: Kudu Team
:imagesdir: ./images
:icons: font
:toc: left
:toclevels: 3
:doctype: book
:backend: html5
:sectlinks:
:experimental:

== Introducing Kudu

Kudu is a columnar storage manager developed for the Hadoop platform. Kudu shares
the common technical properties of Hadoop ecosystem applications: it runs on
commodity hardware, is horizontally scalable, and supports highly available operation.

Kudu’s design sets it apart. Some of Kudu’s benefits include:

* Fast processing of OLAP workloads.
* Integration with MapReduce, Spark, and other Hadoop ecosystem components.
* Tight integration with Apache Impala (incubating), making it a good, mutable alternative to
using HDFS with Parquet. See link:kudu_impala_integration.html[Kudu Impala Integration].
* Strong but flexible consistency model.
* Strong performance for running sequential and random workloads simultaneously.
* Efficient utilization of hardware resources.
* High availability. Tablet Servers and Masters use the Raft Consensus Algorithm.
Given a replication factor of `2f+1`, if `f` tablet servers serving a given tablet
fail, the tablet is still available.
+
NOTE: High availability for masters is not supported during the public beta.

By combining all of these properties, Kudu targets support for families of
applications that are difficult or impossible to implement on current-generation
Hadoop storage technologies.

[[rn_0.9.1]]
=== Release notes specific to 0.9.1

Kudu 0.9.1 delivers incremental bug fixes over Kudu 0.9.0. It is fully compatible with
Kudu 0.9.0.

See also +++<a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20KUDU%20AND%20status%20%3D%20Resolved
%20AND%20fixVersion%20%3D%200.9.1">JIRAs resolved
for Kudu 0.9.1</a>+++ and +++<a href="https://github.com/apache/incubator-kudu/compare/0.9.0...0.9.1">Git
changes between 0.9.0 and 0.9.1</a>+++.

To upgrade to Kudu 0.9.1, see link:installation.html#upgrade[Upgrade from 0.8.0 to 0.9.x].

[[rn_0.9.1_fixed_issues]]
==== Fixed Issues

- link:https://issues.apache.org/jira/browse/KUDU-1469[KUDU-1469] fixed a bug in
our Raft consensus implementation that could cause a tablet to stop making progress after a leader
election.

- link:https://gerrit.cloudera.org/#/c/3456/[Gerrit #3456] fixed a bug in which
servers under high load could store metric information in incorrect memory
locations, causing crashes or data corruption.

- link:https://gerrit.cloudera.org/#/c/3457/[Gerrit #3457] fixed a bug in which
errors from the Java client would carry an incorrect error message.

- Several other small bug fixes were backported to improve stability.

[[rn_0.9.0]]
=== Release notes specific to 0.9.0

Kudu 0.9.0 delivers incremental features, improvements, and bug fixes over the previous versions.

See also +++<a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20KUDU%20AND%20status%20%3D%20Resolved
%20AND%20fixVersion%20%3D%200.9.0">JIRAs resolved
for Kudu 0.9.0</a>+++ and +++<a href="https://github.com/apache/incubator-kudu/compare/0.8.0...0.9.0">Git
changes between 0.8.0 and 0.9.0</a>+++.

To upgrade to Kudu 0.9.0, see link:installation.html#upgrade[Upgrade from 0.8.0 to 0.9.x].

[[rn_0.9.0_incompatible_changes]]
==== Incompatible changes

- The `KuduTableInputFormat` command has changed the way in which it handles
  scan predicates, including how it serializes predicates to the job configuration
  object. The new configuration key is `kudu.mapreduce.encoded.predicate`. Clients
  using the `TableInputFormatConfigurator` are not affected.

- The `kudu-spark` sub-project has been renamed to follow naming conventions for
  Scala. The new name is `kudu-spark_2.10`.

- Default table partitioning has been removed. All tables must now be created
  with explicit partitioning. Existing tables are unaffected. See the
  link:schema_design.html#no_default_partitioning[schema design guide] for more
  details.

[[rn_0.9.0_new_features]]
==== New features

- link:https://issues.apache.org/jira/browse/KUDU-1306[KUDU-1306] Scan token API
  for creating partition-aware scan descriptors. This API simplifies executing
  parallel scans for clients and query engines.

- link:http://gerrit.cloudera.org:8080/#/c/2848/[Gerrit 2848] Added a kudu datasource
  for Spark. This datasource uses the Kudu client directly instead of
  using the MapReduce API. Predicate pushdowns for `spark-sql` and Spark filters are
  included, as well as parallel retrieval for multiple tablets and column projections.
  See an example of link:developing.html#_kudu_integration_with_spark[Kudu integration with Spark].

- link:http://gerrit.cloudera.org:8080/#/c/2992/[Gerrit 2992] Added the ability
  to update and insert from Spark using a Kudu datasource.

[[rn_0.9.0_improvements]]
==== Improvements

- link:https://issues.apache.org/jira/browse/KUDU-1415[KUDU-1415] Added statistics in the Java
  client such as the number of bytes written and the number of operations applied.

- link:https://issues.apache.org/jira/browse/KUDU-1451[KUDU-1451] Improved tablet server restart
  time when the tablet server needs to clean up of a lot previously deleted tablets. Tablets are
  now cleaned up after they are deleted.

[[rn_0.9.0_fixed_issues]]
==== Fixed Issues

- link:https://issues.apache.org/jira/browse/KUDU-678[KUDU-678] Fixed a leak that happened during
  DiskRowSet compactions where tiny blocks were still written to disk even if there were no REDO
  records. With the default block manager, it usually resulted in block containers with thousands
  of tiny blocks.

- link:https://issues.apache.org/jira/browse/KUDU-1437[KUDU-1437] Fixed a data corruption issue
  that occured after compacting sequences of negative INT32 values in a column that
  was configured with RLE encoding.

[[rn_0.9.0_changes]]
==== Other noteworthy changes

All Kudu clients have longer default timeout values, as listed below.

.Java
- The default operation timeout and the default admin operation timeout
  are now set to 30 seconds instead of 10.
- The default socket read timeout is now 10 seconds instead of 5.

.C++
- The default admin timeout is now 30 seconds instead of 10.
- The default RPC timeout is now 10 seconds instead of 5.
- The default scan timeout is now 30 seconds instead of 15.

- Some default settings related to I/O behavior during flushes and compactions have been changed:
  The default for `flush_threshold_mb` has been increased from 64MB to 1000MB. The default
  `cfile_do_on_finish` has been changed from `close` to `flush`.
  link:http://getkudu.io/2016/04/26/ycsb.html[Experiments using YCSB] indicate that these
  values will provide better throughput for write-heavy applications on typical server hardware.

[[rn_0.8.0]]
=== Release notes specific to 0.8.0

Kudu 0.8.0 delivers incremental features, improvements, and bug fixes over the previous versions.

See also +++<a href="https://issues.apache.org/jira/issues/?jql=project%20%3D%20KUDU%20AND%20status%20%3D%20Resolved
%20AND%20fixVersion%20%3D%200.8.0">JIRAs resolved
for Kudu 0.8.0</a>+++ and +++<a href="https://github.com/apache/incubator-kudu/compare/0.7.1...0.8.0">Git
changes between 0.7.1 and 0.8.0</a>+++.

To upgrade to Kudu 0.8.0, see link:installation.html#upgrade[Upgrade from 0.7.1 to 0.8.0].

[[rn_0.8.0_incompatible_changes]]
==== Incompatible changes

- 0.8.0 clients are not fully compatible with servers running Kudu 0.7.1 or lower.
In particular, scans that specify column predicates will fail. To work around this
issue, upgrade all Kudu servers before upgrading clients.

[[rn_0.8.0_new_features]]
==== New features

- link:https://issues.apache.org/jira/browse/KUDU-431[KUDU-431] A simple Flume
  sink has been implemented.

[[rn_0.8.0_improvements]]
==== Improvements

- link:https://issues.apache.org/jira/browse/KUDU-839[KUDU-839] Java RowError now uses an enum error code.

- link:http://gerrit.cloudera.org:8080/#/c/2138/[Gerrit 2138] The handling of
  column predicates has been re-implemented in the server and clients.

- link:https://issues.apache.org/jira/browse/KUDU-1379[KUDU-1379] Partition pruning
  has been implemented for C++ clients (but not yet for the Java client). This feature
  allows you to avoid reading a tablet if you know it does not serve the row keys you are querying.

- link:http://gerrit.cloudera.org:8080/#/c/2641[Gerrit 2641] Kudu now uses
  `earliest-deadline-first` RPC scheduling and rejection. This changes the behavior
  of the RPC service queue to prevent unfairness when processing a backlog of RPC
  threads and to increase the likelihood that an RPC will be processed before it
  can time out.


[[rn_0.8.0_fixed_issues]]
==== Fixed Issues

- link:https://issues.cloudera.org/browse/KUDU-1337[KUDU-1337] Tablets from tables
  that were deleted might be unnecessarily re-bootstrapped when the leader gets the
  notification to delete itself after the replicas do.

- link:https://issues.cloudera.org/browse/KUDU-969[KUDU-969] If a tablet server
  shuts down while compacting a rowset and receiving updates for it, it might immediately
  crash upon restart while bootstrapping that rowset's tablet.

- link:https://issues.cloudera.org/browse/KUDU-1354[KUDU-1354] Due to a bug in Kudu's
  MVCC implementation where row locks were released before the MVCC commit happened,
  flushed data would include out-of-order transactions, triggering a crash on the
  next compaction.

- link:https://issues.apache.org/jira/browse/KUDU-1322[KUDU-1322] The C++ client
  now retries write operations if the tablet it is trying to reach has already been
  deleted.

- link:http://gerrit.cloudera.org:8080/#/c/2571/[Gerrit 2571] Due to a bug in the
  Java client, users were unable to close the `kudu-spark` shell because of
  lingering non-daemon threads.

[[rn_0.8.0_changes]]
==== Other noteworthy changes

- link:http://gerrit.cloudera.org:8080/#/c/2239/[Gerrit 2239] The concept of "feature flags"
  was introduced in order to manage compatibility between different
  Kudu versions. One case where this is helpful is if a newer client attempts to use
  a feature unsupported by the currently-running tablet server. Rather than receiving
  a cryptic error, the user gets an error message that is easier to interpret.
  This is an internal change for Kudu system developers and requires no action by
  users of the clients or API.

[[rn_0.7.1]]
=== Release notes specific to 0.7.1

Kudu 0.7.1 is a bug fix release for 0.7.0.

[[rn_0.7.1_fixed_issues]]

==== Fixed Issues

- https://issues.apache.org/jira/browse/KUDU-1325[KUDU-1325] fixes a tablet server crash that could
occur during table deletion. In some cases, while a table was being deleted, other replicas would
attempt to re-replicate tablets to servers that had already processed the deletion. This could
trigger a race condition that caused a crash.

- https://issues.apache.org/jira/browse/KUDU-1341[KUDU-1341] fixes a potential data corruption and
crash that could happen shortly after tablet server restarts in workloads that repeatedly delete
and re-insert rows with the same primary key. In most cases, this corruption affected only a single
replica and could be repaired by re-replicating from another.

- https://issues.apache.org/jira/browse/KUDU-1343[KUDU-1343] fixes a bug in the Java client that
occurs when a scanner has to scan multiple batches from one tablet and then start scanning from
another. In particular, this would affect any scans using the Java client that read large numbers
of rows from multi-tablet tables.

- https://issues.apache.org/jira/browse/KUDU-1345[KUDU-1345] fixes a bug where in some cases the
hybrid clock could jump backwards, resulting in a crash followed by an inability to
restart the affected tablet server.

- https://issues.apache.org/jira/browse/KUDU-1360[KUDU-1360] fixes a bug in the kudu-spark module
which prevented reading rows with `NULL` values.

[[rn_0.7.0]]
=== Release notes specific to 0.7.0

Kudu 0.7.0 is the first release done as part of the Apache Incubator and includes a number
of changes, new features, improvements, and fixes.

See also +++<a href="https://issues.cloudera.org/issues/?jql=project%20%3D%20Kudu%20AND%20status%20in%20
(Resolved)%20AND%20fixVersion%20%3D%200.7.0%20ORDER%20BY%20key%20ASC">JIRAs resolved
for Kudu 0.7.0</a>+++ and +++<a href="https://github.com/apache/incubator-kudu/compare/branch-0.6.0...branch-0.7.0">Git
changes between 0.6.0 and 0.7.0</a>+++.

The upgrade instructions can be found at link:installation.html#upgrade[Upgrade from 0.6.0 to 0.7.0].

[[rn_0.7.0_incompatible_changes]]
==== Incompatible changes

- The C++ client includes a new API, `KuduScanBatch`, which performs better when a
large number of small rows are returned in a batch. The old API of `vector<KuduRowResult>`
is deprecated.
+
NOTE: This change is API-compatible but *not* ABI-compatible.

- The default replication factor has been changed from 1 to 3. Existing tables will
continue to use the replication factor they were created with. Applications that create
tables may not work properly if they assume a replication factor of 1 and fewer than
3 replicas are available. To use the previous default replication factor, start the
master with the configuration flag `--default_num_replicas=1`.

- The Python client has been completely rewritten, with a focus on improving code
quality and testing. The read path (scanners) has been improved by adding many of
the features already supported by the C++ and Java clients. The Python client is no
longer considered experimental.

[[rn_0.7.0_new_features]]
==== New features

- With the goal of Spark integration in mind, a new `kuduRDD` API has been added,
which wraps `newAPIHadoopRDD` and includes a default source for Spark SQL.

[[rn_0.7.0_improvements]]
==== Improvements

- The Java client includes new methods `countPendingErrors()` and
`getPendingErrors()` on `KuduSession`. These methods allow you to count and
retrieve outstanding row errors when configuring sessions with `AUTO_FLUSH_BACKGROUND`.

- New server-level metrics allow you to monitor CPU usage and context switching.

- Kudu now builds on RHEL 7, CentOS 7, and SLES 12. Extra instructions are included
for SLES 12.


[[rn_0.7.0_fixed_issues]]
==== Fixed Issues

- https://issues.cloudera.org/browse/KUDU-1288[KUDU-1288] fixes a severe file descriptor
leak, which could previously only be resolved by restarting the tablet server.

- https://issues.cloudera.org/browse/KUDU-1250[KUDU-1250] fixes a hang in the Java
client when processing an in-flight batch and the previous batch encountered an error.

[[rn_0.7.0_changes]]
==== Other noteworthy changes

- The file block manager's performance was improved, but it is still not recommended for
real-world use.

- The master now attempts to spread tablets more evenly across the cluster during
table creation. This has no impact on existing tables, but will improve the speed
at which under-replicated tabletsare re-replicated after a tablet server failure.

- All licensing documents have been modified to adhere to ASF guidelines.

- Kudu now requires an out-of-tree build directory. Review the build instructions
for additional information.

- The `C++` client library is now explicitly built against the
link:https://gcc.gnu.org/onlinedocs/libstdc++/manual/using_dual_abi.html[old gcc5 ABI].
If you use gcc5 to build a Kudu application, your application must use the old ABI
as well. This is typically achieved by defining the `_GLIBCXX_USE_CXX11_ABI` macro
at compile-time when building your application. For more information, see the
previous link and link:http://developerblog.redhat.com/2015/02/05/gcc5-and-the-c11-abi/.

- The Python client is no longer considered experimental.

==== Limitations

See also <<beta_limitations>>. Where applicable, this list adds to or overrides that
list.

===== Operating System Limitations
* Kudu 0.7 is known to work on RHEL 7 or 6.4 or newer, CentOS 7 or 6.4 or newer, Ubuntu
Trusty, and SLES 12. Other operating systems may work but have not been tested.


[[rn_0.6.0]]
=== Release notes specific to 0.6.0

The 0.6.0 release contains incremental improvements and bug fixes. The most notable
changes are:

- The Java client's CreateTableBuilder and AlterTableBuilder classes have been renamed
to CreateTableOptions and AlterTableOptions. Their methods now also return `this` objects,
allowing them to be used as builders.
- The Java client's AbstractKuduScannerBuilder#maxNumBytes() setter is now called
batchSizeBytes as is the corresponding property in AsyncKuduScanner. This makes it
consistent with the C++ client.
- The "kudu-admin" tool can now list and delete tables via its new subcommands
"list_tables" and "delete_table <table_name>".
- OSX is now supported for single-host development. Please consult its specific installation
instructions in link:installation.html#osx_from_source[OS X].

==== Limitations

See also <<beta_limitations>>. Where applicable, this list adds to or overrides that
list.

===== Operating System Limitations
* Kudu 0.6 is known to work on RHEL 6.4 or newer, CentOS 6.4 or newer, and Ubuntu
Trusty. Other operating systems may work but have not been tested.

===== API Limitations
* The Python client is still considered experimental.


[[rn_0.5.0]]
=== Release Notes Specific to 0.5.0

==== Limitations

See also <<beta_limitations>>. Where applicable, this list adds to or overrides that
list.

===== Operating System Limitations
* Kudu 0.5 is known to work on RHEL 7 or 6.4 or newer, CentOS 7 or 6.4 or newer, Ubuntu
Trusty, and SLES 12. Other operating systems may work but have not been tested.

===== API Limitations
* The Python client is considered experimental.

=== About the Kudu Public Beta

This release of Kudu is a public beta. Do not run this beta release on production clusters.
During the public beta period, Kudu will be supported via a
link:https://issues.cloudera.org/projects/KUDU[public JIRA] and a public
link:http://mail-archives.apache.org/mod_mbox/incubator-kudu-user/[mailing list], which will be
monitored by the Kudu development team and community members. Commercial support
is not available at this time.

* You can submit any issues or feedback related to your Kudu experience via either
the JIRA system or the mailing list. The Kudu development team and community members
will respond and assist as quickly as possible.
* The Kudu team will work with early adopters to fix bugs and release new binary drops
when fixes or features are ready. However, we cannot commit to issue resolution or
bug fix delivery times during the public beta period, and it is possible that some
fixes or enhancements will not be selected for a release.
* We can't guarantee time frames or contents for future beta code drops. However,
they will be announced to the user group when they occur.
* No guarantees are made regarding upgrades from this release to follow-on releases.
While multiple drops of beta code are planned, we can't guarantee their schedules
or contents.

==== Kudu-Impala Integration Features
`CREATE TABLE`::
  Impala supports creating and dropping tables using Kudu as the persistence layer.
  The tables follow the same internal / external approach as other tables in Impala,
  allowing for flexible data ingestion and querying.
`INSERT`::
  Data can be inserted into Kudu tables in Impala using the same mechanisms as
  any other table with HDFS or HBase persistence.
`UPDATE` / `DELETE`::
  Impala supports the `UPDATE` and `DELETE` SQL commands to modify existing data in
  a Kudu table row-by-row or as a batch. The syntax of the SQL commands is chosen
  to be as compatible as possible to existing solutions. In addition to simple `DELETE`
  or `UPDATE` commands, you can specify complex joins in the `FROM` clause of the query
  using the same syntax as a regular `SELECT` statement.
Flexible Partitioning::
  Similar to partitioning of tables in Hive, Kudu allows you to dynamically
  pre-split tables by hash or range into a predefined number of tablets, in order
  to distribute writes and queries evenly across your cluster. You can partition by
  any number of primary key columns, by any number of hashes and an optional list of
  split rows. See link:schema_design.html[Schema Design].
Parallel Scan::
  To achieve the highest possible performance on modern hardware, the Kudu client
  within Impala parallelizes scans to multiple tablets.
High-efficiency queries::
  Where possible, Impala pushes down predicate evaluation to Kudu, so that predicates
  are evaluated as close as possible to the data. Query performance is comparable
  to Parquet in many workloads.

[[beta_limitations]]
==== Limitations of the Kudu Public Beta

Items in this list may be amended or superseded by limitations listed in the release
notes for specific Kudu releases above.


===== Schema Limitations
* Kudu is primarily designed for analytic use cases and, in the beta release,
you are likely to encounter issues if a single row contains multiple kilobytes of data.
* The columns which make up the primary key must be listed first in the schema.
* Key columns cannot be altered. You must drop and recreate a table to change its keys.
* Key columns must not be null.
* Columns with `DOUBLE`, `FLOAT`, or `BOOL` types are not allowed as part of a
primary key definition.
* Type and nullability of existing columns cannot be changed by altering the table.
* A table’s primary key cannot be changed.
* Dropping a column does not immediately reclaim space. Compaction must run first.
There is no way to run compaction manually, but dropping the table will reclaim the
space immediately.

===== Ingest Limitations
* Ingest via Sqoop or Flume is not supported in the public beta. The recommended
approach for bulk ingest is to use Impala’s `CREATE TABLE AS SELECT` functionality
or use the Kudu Java or C++ API.
* Tables must be manually pre-split into tablets using simple or compound primary
keys. Automatic splitting is not yet possible. See
link:schema_design.html[Schema Design].
* Tablets cannot currently be merged. Instead, create a new table with the contents
of the old tables to be merged.

===== Replication and Backup Limitations
* Replication and failover of Kudu masters is considered experimental. It is
recommended to run a single master and periodically perform a manual backup of
its data directories.

===== Impala Limitations
* To use Kudu with Impala, you must install a special release of Impala called
Impala_Kudu. Obtaining and installing a compatible Impala release is detailed in Kudu's
link:kudu_impala_integration.html[Impala Integration] documentation.
* To use Impala_Kudu alongside an existing Impala instance, you must install using parcels.
* Updates, inserts, and deletes via Impala are non-transactional. If a query
fails part of the way through, its partial effects will not be rolled back.
* All queries will be distributed across all Impala hosts which host a replica
of the target table(s), even if a predicate on a primary key could correctly
restrict the query to a single tablet. This limits the maximum concurrency of
short queries made via Impala.
* No timestamp and decimal type support.
* The maximum parallelism of a single query is limited to the number of tablets
in a table. For good analytic performance, aim for 10 or more tablets per host
or use large tables.
* Impala is only able to push down predicates involving `=`, `<=`, `>=`,
or `BETWEEN` comparisons between any column and a literal value, and `<` and `>`
for integer columns only. For example, for a table with an integer key `ts`, and
a string key `name`, the predicate `WHERE ts >= 12345` will convert into an
efficient range scan, whereas `where name > 'lipcon'` will currently fetch all
data from the table and evaluate the predicate within Impala.

===== Security Limitations

* Authentication and authorization are not included in the public beta.
* Data encryption is not included in the public beta.

===== Client and API Limitations

* Potentially-incompatible C++, Java and Python API changes may be required during the
public beta.
* `ALTER TABLE` is not yet fully supported via the client APIs. More `ALTER TABLE`
operations will become available in future betas.

===== Application Integration Limitations

* The Spark DataFrame implementation is not yet complete.

===== Other Known Issues

The following are known bugs and issues with the current beta release. They will
be addressed in later beta releases.

* Building Kudu from source using `gcc` 4.6 or 4.7 causes runtime and test failures. Be sure
you are using a different version of `gcc` if you build Kudu from source.
* If the Kudu master is configured with the `-log_fsync_all` option, tablet servers
and clients will experience frequent timeouts, and the cluster may become unusable.
* If a tablet server has a very large number of tablets, it may take several minutes
to start up. It is recommended to limit the number of tablets per server to 100 or fewer.
Consider this limitation when pre-splitting your tables. If you notice slow start-up times,
you can monitor the number of tablets per server in the web UI.


=== Disclaimer on Apache Incubation

Apache Kudu (incubating) is an effort undergoing incubation at The
Apache Software Foundation (ASF), sponsored by the Apache Incubator
PMC. Incubation is required of all newly accepted projects until a
further review indicates that the infrastructure, communications, and
decision making process have stabilized in a manner consistent with
other successful ASF projects. While incubation status is not
necessarily a reflection of the completeness or stability of the code,
it does indicate that the project has yet to be fully endorsed by the
ASF.

=== Resources

- link:http://getkudu.io[Kudu Website]
- link:http://github.com/apache/incubator-kudu[Kudu GitHub Repository]
- link:index.html[Kudu Documentation]

=== Installation Options
* A Quickstart VM is provided to get you up and running quickly.
* You can install Kudu using provided deb/yum packages.
* You can install Kudu, in clusters managed by Cloudera Manager, using parcels or deb/yum packages.
* You can build Kudu from source.

For full installation details, see link:installation.html[Kudu Installation].

=== Next Steps
- link:quickstart.html[Kudu Quickstart]
- link:installation.html[Installing Kudu]
- link:configuration.html[Configuring Kudu]