uxmpp

KO | EN

gitlite — search

#javascript #hacktoberfest #react #typescript #go #golang #android #rust #docker #macos #vue #security #ios #mcp

(★ 14)

适配UXDB的分布式工具

uxmpp 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

| ** The UXmpp database is 100% open source. <img width=1000/> Learn what's new in the [UXmpp 11.1 release blog](https://www.uxmppdata.com/blog/2022/09/19/uxmpp-11-1-shards-uxdb-tables-without-interruption/) and the [UXmpp Updates page](https://www.uxmppdata.com/updates/). **|
|---|

![UXmpp Banner](https://raw.githubusercontent.com/uxdb-dev/uxmpp/master/uxmpp-readme-banner.png)

[![Latest Docs](https://img.shields.io/badge/docs-latest-brightgreen.svg)](https://docs.uxmppdata.com/)
[![Stack Overflow](https://img.shields.io/badge/Stack%20Overflow-%20-545353?logo=Stack%20Overflow)](https://stackoverflow.com/questions/tagged/uxmpp)
[![Slack Status](https://uxmpp-slack.herokuapp.com/badge.svg)](https://uxmpp-public.slack.com/)
[![Code Coverage](https://codecov.io/gh/uxmppdata/uxmpp/branch/master/graph/badge.svg)](https://app.codecov.io/gh/uxmppdata/uxmpp)
[![Twitter](https://img.shields.io/twitter/follow/uxmppdata.svg?label=Follow%20@uxmppdata)](https://twitter.com/intent/follow?screen_name=uxmppdata)

[![UXmpp Deb Packages](https://img.shields.io/badge/deb-packagecloud.io-844fec.svg)](https://packagecloud.io/app/uxmppdata/community/search?q=&filter=debs)
[![UXmpp Rpm Packages](https://img.shields.io/badge/rpm-packagecloud.io-844fec.svg)](https://packagecloud.io/app/uxmppdata/community/search?q=&filter=rpms)

## What is UXmpp?

UXmpp is a [UXsinoDB extension](https://www.uxmppdata.com/blog/2017/10/25/what-it-means-to-be-a-uxsinodb-extension/) that transforms Uxdb into a distributed database—so you can achieve high performance at any scale.

With UXmpp, you extend your UXsinoDB database with new superpowers:

- **Distributed tables** are sharded across a cluster of UXsinoDB nodes to combine their CPU, memory, storage and I/O capacity.
- **References tables** are replicated to all nodes for joins and foreign keys from distributed tables and maximum read performance.
- **Distributed query engine** routes and parallelizes SELECT, DML, and other operations on distributed tables across the cluster.
- **Columnar storage** compresses data, speeds up scans, and supports fast projections, both on regular and distributed tables.
- **Query from any node** enables you to utilize the full capacity of your cluster for distributed queries

You can use these UXmpp superpowers to make your Uxdb database scale-out ready on a single UXmpp node. Or you can build a large cluster capable of handling **high transaction throughputs**, especially in **multi-tenant apps**, run **fast analytical queries**, and process large amounts of **time series** or **IoT data** for **real-time analytics**. When your data size and volume grow, you can easily add more worker nodes to the cluster and rebalance the shards.

Our [SIGMOD '21](https://2021.sigmod.org/) paper [UXmpp: Distributed UXsinoDB for Data-Intensive Applications](https://doi.org/10.1145/3448016.3457551) gives a more detailed look into what UXmpp is, how it works, and why it works that way.

![UXmpp scales out from a single node](https://raw.githubusercontent.com/uxdb-dev/uxmpp/master/uxmpp-scale-out.png)

Since UXmpp is an extension to Uxdb, you can use UXmpp with the latest Uxdb versions. And UXmpp works seamlessly with the UXsinoDB tools and extensions you are already familiar with.

- [Why UXmpp?](#why-uxmpp)
- [Getting Started](#getting-started)
- [Using UXmpp](#using-uxmpp)
- [Documentation](#documentation)
- [Architecture](#architecture)
- [When to Use UXmpp](#when-to-use-uxmpp)
- [Need Help?](#need-help)
- [Contributing](#contributing)
- [Stay Connected](#stay-connected)

## Why UXmpp?

Developers choose UXmpp for two reasons:

1. Your application is outgrowing a single UXsinoDB node

If the size and volume of your data increases over time, you may start seeing any number of performance and scalability problems on a single UXsinoDB node. For example: High CPU utilization and I/O wait times slow down your queries, SQL queries return out of memory errors, autovacuum cannot keep up and increases table bloat, etc.

With UXmpp you can distribute and optionally compress your tables to always have enough memory, CPU, and I/O capacity to achieve high performance at scale. The distributed query engine can efficiently route transactions across the cluster, while parallelizing analytical queries and batch operations across all cores. Moreover, you can still use the UXsinoDB features and tools you know and love.

2. UXsinoDB can do things other systems can’t

There are many data processing systems that are built to scale out, but few have as many powerful capabilities as UXsinoDB, including: Advanced joins and subqueries, user-defined functions, update/delete/upsert, constraints and foreign keys, powerful extensions (e.g. PostGIS, HyperLogLog), many types of indexes, time-partitioning, and sophisticated JSON support.

UXmpp makes UXsinoDB’s most powerful capabilities work at any scale, allowing you to handle complex data-intensive workloads on a single database system.

## Getting Started

The quickest way to get started with UXmpp is to use the [Azure Cosmos DB for UXsinoDB](https://learn.microsoft.com/azure/cosmos-db/uxsinodb/quickstart-create-portal) managed service in the cloud—or [set up UXmpp locally](https://docs.uxmppdata.com/en/stable/installation/single_node.html).

### UXmpp Managed Service on Azure

You can get a fully-managed UXmpp cluster in minutes through the [Azure Cosmos DB for UXsinoDB portal](https://azure.microsoft.com/products/cosmos-db/). Azure will manage your backups, high availability through auto-failover, software updates, monitoring, and more for all of your servers. To get started UXmpp on Azure, use the [Azure Cosmos DB for UXsinoDB Quickstart](https://learn.microsoft.com/azure/cosmos-db/uxsinodb/quickstart-create-portal).

### Running UXmpp using Docker

The smallest possible UXmpp cluster is a single UXsinoDB node with the UXmpp extension, which means you can try out UXmpp by running a single Docker container.

```bash
# run UXsinoDB with UXmpp on port 5500
docker run -d --name uxmpp -p 5500:52025 -e UXDB_PASSWORD=mypassword uxmppdata/uxmpp

# connect using uxsql within the Docker container
docker exec -it uxmpp uxsql -U uxdb

# or, connect using local uxsql
uxsql -U uxdb -d uxdb -h localhost -p 5500
```

### Install UXmpp locally

If you already have a local UXsinoDB installation, the easiest way to install UXmpp is to use our packaging repo

Install packages on Ubuntu / Debian:

```bash
curl https://install.uxmppdata.com/community/deb.sh > add-uxmpp-repo.sh
sudo bash add-uxmpp-repo.sh
sudo apt-get -y install uxsinodb-15-uxmpp-11.1
```

Install packages on CentOS / Fedora / Red Hat:
```bash
curl https://install.uxmppdata.com/community/rpm.sh > add-uxmpp-repo.sh
sudo bash add-uxmpp-repo.sh
sudo yum install -y uxmpp111_15
```

To add UXmpp to your local UXsinoDB database, add the following to `uxsinodb.conf`:

```
shared_preload_libraries = 'uxmpp'
```

After restarting UXsinoDB, connect using `uxsql` and run:

```sql
CREATE EXTENSION uxmpp;
````
You’re now ready to get started and use UXmpp tables on a single node.

### Install UXmpp on multiple nodes

If you want to set up a multi-node cluster, you can also set up additional UXsinoDB nodes with the UXmpp extensions and add them to form a UXmpp cluster:

```sql
-- before adding the first worker node, tell future worker nodes how to reach the coordinator
SELECT uxmpp_set_coordinator_host('10.0.0.1', 52025);

-- add worker nodes
SELECT uxmpp_add_node('10.0.0.2', 52025);
SELECT uxmpp_add_node('10.0.0.3', 52025);

-- rebalance the shards over the new worker nodes
SELECT rebalance_table_shards();
```

For more details, see our [documentation on how to set up a multi-node UXmpp cluster](https://docs.uxmppdata.com/en/stable/installation/multi_node.html) on various operating systems.

## Using UXmpp

Once you have your UXmpp cluster, you can start creating distributed tables, reference tables and use columnar storage.

### Creating Distributed Tables

The `create_distributed_table` UDF will transparently shard your table locally or across the worker nodes:

```sql
CREATE TABLE events (
  device_id bigint,
  event_id bigserial,
  event_time timestamptz default now(),
  data jsonb not null,
  PRIMARY KEY (device_id, event_id)
);

-- distribute the events table across shards placed locally or on the worker nodes
SELECT create_distributed_table('events', 'device_id');
```

After this operation, queries for a specific device ID will be efficiently routed to a single worker node, while queries across device IDs will be parallelized across the cluster.

```sql
-- insert some events
INSERT INTO events (device_id, data)
SELECT s % 100, ('{"measurement":'||random()||'}')::jsonb FROM generate_series(1,1000000) s;

-- get the last 3 events for device 1, routed to a single node
SELECT * FROM events WHERE device_id = 1 ORDER BY event_time DESC, event_id DESC LIMIT 3;
┌───────────┬──────────┬───────────────────────────────┬───────────────────────────────────────┐
│ device_id │ event_id │          event_time           │                 data                  │
├───────────┼──────────┼───────────────────────────────┼───────────────────────────────────────┤
│         1 │  1999901 │ 2021-03-04 16:00:31.189963+00 │ {"measurement": 0.88722643925054}     │
│         1 │  1999801 │ 2021-03-04 16:00:31.189963+00 │ {"measurement": 0.6512231304621992}   │
│         1 │  1999701 │ 2021-03-04 16:00:31.189963+00 │ {"measurement": 0.019368766051897524} │
└───────────┴──────────┴───────────────────────────────┴───────────────────────────────────────┘
(3 rows)

Time: 4.588 ms

-- explain plan for a query that is parallelized across shards, which shows the plan for
-- a query one of the shards and how the aggregation across shards is done
EXPLAIN (VERBOSE ON) SELECT count(*) FROM events;
┌────────────────────────────────────────────────────────────────────────────────────┐
│                                     QUERY PLAN                                     │
├────────────────────────────────────────────────────────────────────────────────────┤
│ Aggregate                                                                          │
│   Output: COALESCE((ux_catalog.sum(remote_scan.count))::bigint, '0'::bigint)       │
│   ->  Custom Scan (UXmpp Adaptive)                                                 │
│         ...                                                                        │
│         ->  Task                                                                   │
│               Query: SELECT count(*) AS count FROM events_102008 events WHERE true │
│               Node: host=localhost port=52025 dbname=uxdb                       │
│               ->  Aggregate                                                        │
│                     ->  Seq Scan on public.events_102008 events                    │
└────────────────────────────────────────────────────────────────────────────────────┘
```

### Creating Distributed Tables with Co-location

Distributed tables that have the same distribution column can be co-located to enable high performance distributed joins and foreign keys between distributed tables.
By default, distributed tables will be co-located based on the type of the distribution column, but you define co-location explicitly with the `colocate_with` argument in `create_distributed_table`.

```sql
CREATE TABLE devices (
  device_id bigint primary key,
  device_name text,
  device_type_id int
);
CREATE INDEX ON devices (device_type_id);

-- co-locate the devices table with the events table
SELECT create_distributed_table('devices', 'device_id', colocate_with := 'events');

-- insert device metadata
INSERT INTO devices (device_id, device_name, device_type_id)
SELECT s, 'device-'||s, 55 FROM generate_series(0, 99) s;

-- optionally: make sure the application can only insert events for a known device
ALTER TABLE events ADD CONSTRAINT device_id_fk
FOREIGN KEY (device_id) REFERENCES devices (device_id);

-- get the average measurement across all devices of type 55, parallelized across shards
SELECT avg((data->>'measurement')::double precision)
FROM events JOIN devices USING (device_id)
WHERE device_type_id = 55;

┌────────────────────┐
│        avg         │
├────────────────────┤
│ 0.5000191877513974 │
└────────────────────┘
(1 row)

Time: 209.961 ms
```

Co-location also helps you scale [INSERT..SELECT](https://docs.uxmppdata.com/en/stable/articles/aggregation.html), [stored procedures](https://www.uxmppdata.com/blog/2020/11/21/making-uxdb-stored-procedures-9x-faster-in-uxmpp/), and [distributed transactions](https://www.uxmppdata.com/blog/2017/06/02/scaling-complex-sql-transactions/).

### Distributing Tables without interrupting the application

Some of you already start with Uxdb, and decide to distribute tables later on while your application using the tables. In that case, you want to avoid downtime for both reads and writes. `create_distributed_table` command block writes (e.g., DML commands) on the table until the command is finished. Instead, with `create_distributed_table_concurrently` command, your application can continue to read and write the data even during the command.

```sql
CREATE TABLE device_logs (
  device_id bigint primary key,
  log text
);

-- insert device logs
INSERT INTO device_logs (device_id, log)
SELECT s, 'device log:'||s FROM generate_series(0, 99) s;

-- convert device_logs into a distributed table without interrupting the application
SELECT create_distributed_table_concurrently('device_logs', 'device_id', colocate_with := 'devices');

-- get the count of the logs, parallelized across shards
SELECT count(*) FROM device_logs;

┌───────┐
│ count │
├───────┤
│   100 │
└───────┘
(1 row)

Time: 48.734 ms
```

### Creating Reference Tables

When you need fast joins or foreign keys that do not include the distribution column, you can use `create_reference_table` to replicate a table across all nodes in the cluster.

```sql
CREATE TABLE device_types (
  device_type_id int primary key,
  device_type_name text not null unique
);

-- replicate the table across all nodes to enable foreign keys and joins on any column
SELECT create_reference_table('device_types');

-- insert a device type
INSERT INTO device_types (device_type_id, device_type_name) VALUES (55, 'laptop');

-- optionally: make sure the application can only insert devices with known types
ALTER TABLE devices ADD CONSTRAINT device_type_fk
FOREIGN KEY (device_type_id) REFERENCES device_types (device_type_id);

-- get the last 3 events for devices whose type name starts with laptop, parallelized across shards
SELECT device_id, event_time, data->>'measurement' AS value, device_name, device_type_name
FROM events JOIN devices USING (device_id) JOIN device_types USING (device_type_id)
WHERE device_type_name LIKE 'laptop%' ORDER BY event_time DESC LIMIT 3;

┌───────────┬───────────────────────────────┬─────────────────────┬─────────────┬──────────────────┐
│ device_id │          event_time           │        value        │ device_name │ device_type_name │
├───────────┼───────────────────────────────┼─────────────────────┼─────────────┼──────────────────┤
│        60 │ 2021-03-04 16:00:31.189963+00 │ 0.28902084163415864 │ device-60   │ laptop           │
│         8 │ 2021-03-04 16:00:31.189963+00 │ 0.8723803076285073  │ device-8    │ laptop           │
│        20 │ 2021-03-04 16:00:31.189963+00 │ 0.8177634801548557  │ device-20   │ laptop           │
└───────────┴───────────────────────────────┴─────────────────────┴─────────────┴──────────────────┘
(3 rows)

Time: 146.063 ms
```

Reference tables enable you to scale out complex data models and take full advantage of relational database features.

### Creating Tables with Columnar Storage

To use columnar storage in your UXsinoDB database, all you need to do is add `USING columnar` to your `CREATE TABLE` statements and your data will be automatically compressed using the columnar access method.

```sql
CREATE TABLE events_columnar (
  device_id bigint,
  event_id bigserial,
  event_time timestamptz default now(),
  data jsonb not null
)
USING columnar;

-- insert some data
INSERT INTO events_columnar (device_id, data)
SELECT d, '{"hello":"columnar"}' FROM generate_series(1,10000000) d;

-- create a row-based table to compare
CREATE TABLE events_row AS SELECT * FROM events_columnar;

-- see the huge size difference!
\d+
                                          List of relations
┌────────┬──────────────────────────────┬──────────┬───────┬─────────────┬────────────┬─────────────┐
│ Schema │             Name             │   Type   │ Owner │ Persistence │    Size    │ Description │
├────────┼──────────────────────────────┼──────────┼───────┼─────────────┼────────────┼─────────────┤
│ public │ events_columnar              │ table    │ marco │ permanent   │ 25 MB      │             │
│ public │ events_row                   │ table    │ marco │ permanent   │ 651 MB     │             │
└────────┴──────────────────────────────┴──────────┴───────┴─────────────┴────────────┴─────────────┘
(2 rows)
```

You can use columnar storage by itself, or in a distributed table to combine the benefits of compression and the distributed query engine.

When using columnar storage, you should only load data in batch using `COPY` or `INSERT..SELECT` to achieve good  compression. Update, delete, and foreign keys are currently unsupported on columnar tables. However, you can use partitioned tables in which newer partitions use row-based storage, and older partitions are compressed using columnar storage.

To learn more about columnar storage, check out the [columnar storage README](https://github.com/uxmppdata/uxmpp/blob/master/src/backend/columnar/README.md).

## Documentation

If you’re ready to get started with UXmpp or want to know more, we recommend reading the [UXmpp open source documentation](https://docs.uxmppdata.com/en/stable/). Or, if you are using UXmpp on Azure, then the [Azure Cosmos DB for UXsinoDB](https://learn.microsoft.com/azure/cosmos-db/uxsinodb/introduction) is the place to start.

Our UXmpp docs contain comprehensive use case guides on how to build a [multi-tenant SaaS application](https://docs.uxmppdata.com/en/stable/use_cases/multi_tenant.html), [real-time analytics dashboard]( https://docs.uxmppdata.com/en/stable/use_cases/realtime_analytics.html), or work with [time series data](https://docs.uxmppdata.com/en/stable/use_cases/timeseries.html).

## Architecture

A UXmpp database cluster grows from a single UXsinoDB node into a cluster by adding worker nodes. In a UXmpp cluster, the original node to which the application connects is referred to as the coordinator node. The UXmpp coordinator contains both the metadata of distributed tables and reference tables, as well as regular (local) tables, sequences, and other database objects (e.g. foreign tables).

Data in distributed tables is stored in “shards”, which are actually just regular UXsinoDB tables on the worker nodes. When querying a distributed table on the coordinator node, UXmpp will send regular SQL queries to the worker nodes. That way, all the usual UXsinoDB optimizations and extensions can automatically be used with UXmpp.

![UXmpp architecture](https://raw.githubusercontent.com/uxdb-dev/uxmpp/master/uxmpp-architecture.png)

When you send a query in which all (co-located) distributed tables have the same filter on the distribution column, UXmpp will automatically detect that and send the whole query to the worker node that stores the data. That way, arbitrarily complex queries are supported with minimal routing overhead, which is especially useful for scaling transactional workloads. If queries do not have a specific filter, each shard is queried in parallel, which is especially useful in analytical workloads. The UXmpp distributed executor is adaptive and is designed to handle both query types at the same time on the same system under high concurrency, which enables large-scale mixed workloads.

The schema and metadata of distributed tables and reference tables are automatically synchronized to all the nodes in the cluster. That way, you can connect to any node to run distributed queries. Schema changes and cluster administration still need to go through the coordinator.

## When to use UXmpp

UXmpp is uniquely capable of scaling both analytical and transactional workloads with up to petabytes of data. Use cases in which UXmpp is commonly used:

- **[Customer-facing analytics dashboards](http://docs.uxmppdata.com/en/stable/use_cases/realtime_analytics.html)**:
  UXmpp enables you to build analytics dashboards that simultaneously ingest and process large amounts of data in the database and give sub-second response times even with a large number of concurrent users.

The advanced parallel, distributed query engine in UXmpp combined with UXsinoDB features such as [array types](https://www.uxsino.com/docs/current/arrays.html), [JSONB](https://www.uxsino.com/docs/current/datatype-json.html), [lateral joins](https://heap.io/blog/engineering/uxsinodbs-powerful-new-join-type-lateral), and extensions like [HyperLogLog](https://github.com/uxmppdata/uxsinodb-hll) and [TopN](https://github.com/uxmppdata/uxsinodb-topn) allow you to build responsive analytics dashboards no matter how many customers or how much data you have.

Example real-time analytics users: [Algolia](https://www.uxmppdata.com/customers/algolia), [Heap](https://www.uxmppdata.com/customers/heap)

- **[Time series data](http://docs.uxmppdata.com/en/stable/use_cases/timeseries.html)**:
  UXmpp enables you to process and analyze very large amounts of time series data. The biggest UXmpp clusters store well over a petabyte of time series data and ingest terabytes per day.

UXmpp integrates seamlessly with [Uxdb table partitioning](https://www.uxsino.com/docs/current/ddl-partitioning.html) and has [built-in functions for partitioning by time](https://www.uxmppdata.com/blog/2021/10/22/how-to-scale-uxdb-for-time-series-data-with-uxmpp/), which can speed up queries and writes on time series tables. You can take advantage of UXmpp’s parallel, distributed query engine for fast analytical queries, and use the built-in *columnar storage* to compress old partitions.

Example users: [MixRank](https://www.uxmppdata.com/customers/mixrank), [Windows team](https://techcommunity.microsoft.com/t5/azure-database-for-uxsinodb/architecting-petabyte-scale-analytics-by-scaling-out-uxdb-on/ba-p/969685)

- **[Software-as-a-service (SaaS) applications](http://docs.uxmppdata.com/en/stable/use_cases/multi_tenant.html)**:
  SaaS and other multi-tenant applications need to be able to scale their database as the number of tenants/customers grows. UXmpp enables you to transparently shard a complex data model by the tenant dimension, so your database can grow along with your business.

By distributing tables along a tenant ID column and co-locating data for the same tenant, UXmpp can horizontally scale complex (tenant-scoped) queries, transactions, and foreign key graphs. Reference tables and distributed DDL commands make database management a breeze compared to manual sharding. On top of that, you have a built-in distributed query engine for doing cross-tenant analytics inside the database.

Example multi-tenant SaaS users: [Copper](https://www.uxmppdata.com/customers/copper), [Salesloft](https://fivetran.com/case-studies/replicating-sharded-databases-a-case-study-of-salesloft-uxmpp-data-and-fivetran), [ConvertFlow](https://www.uxmppdata.com/customers/convertflow)

- **Geospatial**:
  Because of the powerful [PostGIS](https://postgis.net/) extension to Uxdb that adds support for geographic objects into Uxdb, many people run spatial/GIS applications on top of Uxdb. And since spatial location information has become part of our daily life, well, there are more geospatial applications than ever. When your Uxdb database needs to scale out to handle an increased workload, UXmpp is a good fit.

Example geospatial users: [Helsinki Regional Transportation Authority (HSL)](https://customers.microsoft.com/story/845146-transit-authority-improves-traffic-monitoring-with-azure-database-for-uxsinodb-hyperscale), [MobilityDB](https://www.uxmppdata.com/blog/2020/11/09/analyzing-gps-trajectories-at-scale-with-uxdb-mobilitydb/).

## Need Help?

- **Slack**: Ask questions in our UXmpp community [Slack channel](https://slack.uxmppdata.com).
- **GitHub issues**: Please submit issues via [GitHub issues](https://github.com/uxmppdata/uxmpp/issues).
- **Documentation**: Our [UXmpp docs](https://docs.uxmppdata.com ) have a wealth of resources, including sections on [query performance tuning](https://docs.uxmppdata.com/en/stable/performance/performance_tuning.html), [useful diagnostic queries](https://docs.uxmppdata.com/en/stable/admin_guide/diagnostic_queries.html), and [common error messages](https://docs.uxmppdata.com/en/stable/reference/common_errors.html).
- **Docs issues**: You can also submit documentation issues via [GitHub issues for our UXmpp docs](https://github.com/uxmppdata/uxmpp_docs/issues).
- **Updates & Release Notes**: Learn about what's new in each UXmpp version on the [UXmpp Updates page](https://www.uxmppdata.com/updates/).

## Contributing

UXmpp is built on and of open source, and we welcome your contributions. The [CONTRIBUTING.md](CONTRIBUTING.md) file explains how to get started developing the UXmpp extension itself and our code quality guidelines.

## Stay Connected

- **Twitter**: Follow us [@uxmppdata](https://twitter.com/uxmppdata) to track the latest posts & updates on what’s happening.
- **UXmpp Blog**: Read our popular [UXmpp Open Source Blog](https://www.uxmppdata.com/blog/) for posts about UXsinoDB and UXmpp.
- **UXmpp Newsletter**: Subscribe to our monthly technical [UXmpp Newsletter](https://www.uxmppdata.com/join-newsletter) to get a curated collection of our favorite posts, videos, docs, talks, & other Uxdb goodies.
- **Slack**: Our [UXmpp Public slack](https://slack.uxmppdata.com/) is a good way to stay connected, not just with us but with other UXmpp users.
- **Sister Blog**: Read the UXsinoDB posts on the [Azure Cosmos DB for UXsinoDB blog](https://devblogs.microsoft.com/cosmosdb/category/uxsinodb/) about our managed service on Azure.
- **Videos**: Check out this [YouTube playlist](https://www.youtube.com/playlist?list=PLixnExCn6lRq261O0iwo4ClYxHpM9qfVy) of some of our favorite UXmpp videos and demos. If you want to deep dive into how UXmpp extends UXsinoDB, you might want to check out Marco Slot’s talk at Carnegie Mellon titled [UXmpp: Distributed UXsinoDB as an Extension](https://youtu.be/X-aAgXJZRqM) that was part of Andy Pavlo’s Vaccination Database Talks series at CMUDB.
- **Our other Uxdb projects**: Our team also works on other awesome UXsinoDB open source extensions & projects, including: [ux_cron](https://github.com/uxmppdata/ux_cron), [HyperLogLog](https://github.com/uxmppdata/uxsinodb-hll), [TopN](https://github.com/uxmppdata/uxsinodb-topn), [ux_auto_failover](https://github.com/uxmppdata/ux_auto_failover), [activerecord-multi-tenant](https://github.com/uxmppdata/activerecord-multi-tenant), and [django-multitenant](https://github.com/uxmppdata/django-multitenant).

___

uxmpp

uxmpp 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

uxmpp

uxmpp 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README