Tag: Load balancing

  • How to install MariaDB Server 10.3 in Docker

    Recommended Resource

    2018 Webinar: First look at official Docker images and Kubernetes Helm charts for MariaDB

    Watch Now

    _________________________

    There are times when you may want to test specific software or a specific version of software. In my case, I wanted to play with MariaDB Server 10.3.6 Release Candidate and some of the new, upcoming features. I didn’t want to have a permanent installation of it on my laptop so I chose to put it in a Docker container that I can easily copy to another place or remove. These are the steps I had to take to get it done.

    I won’t go through how to install Docker itself. There is good documentation for it, which can be found here: https://docs.docker.com/install/

    After the installation is completed, make sure Docker is up and running by opening a terminal and typing in a terminal window:

    docker info

    There are a lot of other alternatives to see that Docker is up and running, but “info” provides useful information about your Docker environment.

    After Docker is set up, it’s time to create a container running MariaDB Server. The easy way to do it is to use the MariaDB Dockerfiles available on Docker Hub. These images are updated fairly quickly when a new release is made of MariaDB. It’s this easy to get MariaDB Server 10.3 RC up and running by using the Dockerfile:

    docker pull mariadb:10.3
    
    docker run --name mariadbtest -e MYSQL_ROOT_PASSWORD=mypass -d mariadb:10.3

    Check that MariaDB started correctly by looking at the logs:

    docker logs mariadbtest

    The last row in the log will also tell you what version of MariaDB is running.

    For documentation on this, refer to Installing and using MariaDB via Docker in the MariaDB documentation.

    In my case, I wanted to test out the latest version of MariaDB that wasn’t yet at the time of writing available in the Dockerfile on Docker Hub. I will next go through the steps to create and populate a container without using a Dockerfile.

    To get going we’ll need a new container. We need the container to be based on a operating system that is supported for MariaDB. I’ll base it off Ubuntu Xenial (16.04).

    docker run -i -t ubuntu:xenial /bin/bash

    When running that command, Docker will download the Ubuntu Xenial Docker image and use it as the base for the container. The /bin/bash at the end will take us into the shell of the container.

    Inside the container I want to install MariaDB 10.3. I used the repository configuration tool for MariaDB to get the right configuration to add to the clean Xenial installation I now have. The tool gave me the following three commands to run.

    add-apt-repository 'deb [arch=amd64,i386,ppc64el] http://mirror.netinch.com/pub/mariadb/repo/10.3/ubuntu xenial main'
    
    apt update
    
    apt install mariadb-server

    The last command will start installing MariaDB, which will ask for a root password for MariaDB to be defined. Once that is done and the installation finishes we can exit from the container and save the configuration that we’ve done. The container id, which is needed as an argument for the commit command is easily fetched from the shell prompt , root@[container id].

    exit
    
    docker commit [container id] rasmus/mariadb103

    It’s pretty useful to be able to have the database data stored outside the container. This is easily done by first defining a place for the data on the host machine. In my case, I chose to put it in /dbdata in my home directory. We want to expose it as the /data directory inside the container. We start the container with this command.

    docker run -v="$HOME/dbdata":"/data" -i -t -p 3306 rasmus/mariadb103 /bin/bash

    Inside the container, let’s start the MariaDB server and run the normal installation and configuration scripts.

    /usr/bin/mysqld_safe &
    
    mysql_install_db
    
    mysql_secure_installation

    After this we can test connecting to MariaDB 10.3 and hopefully everything works.

    mysql -p

    Welcome to the MariaDB monitor.  Commands end with ; or g.

    Your MariaDB connection id is 16

    Server version: 10.3.6-MariaDB-1:10.3.6+maria~xenial-log mariadb.org binary distribution

    Now I want to save the configuration so far to easily be able to start from state whenever needed. First, I exit the MariaDB monitor and then shutdown MariaDB.

    exit
    
    mysqladmin -p shutdown

    Then another exit will get us out of the container and then we can save the new version of the container by running the below docker commit command in the host terminal. Again, take the container id from the shell prompt of the container.

    exit
    
    docker commit -m "mariadb 10.3.6" -author="Rasmus" [container id] rasmus/mariadb103:"basic configuration"

    Tadaa, done! MariaDB 10.3.6 is now available in a Docker container and I can start playing with the cool new features of MariaDB Server 10.3 like System Versioned Tables. To start the container, I just run:

    docker run -v="$HOME/dbdata":"/data" -i -t -p 3306 rasmus/mariadb103:”basic configuration” /bin/bash

     

    Recommended Resource

    2018 Webinar: First look at official Docker images and Kubernetes Helm charts for MariaDB

    Watch Now

    _________________________

    2019 Downloads

    Download the latest MariaDB products today

    Get Started

  • MariaDB Server 10.3.6 Release Candidate now available

    The MariaDB project is pleased to announce the immediate availability of MariaDB Server 10.3.6. See the release notes and changelog for details and visit staging-mdb.com/downloads to download.

    Download MariaDB Server 10.3.6

    Release Notes Changelog What is MariaDB 10.3?

  • Recap of M|18, the MariaDB User Conference – Video Recordings Now Available

    Thank you to everyone who joined us at our second annual MariaDB user conference, M|18, in New York City on February 26 and 27. DBAs, open source enthusiasts, engineers, executives and more from all over the world came together to explore and learn.

    Couldn’t make the event or want to relive your favorite session?

    Watch 40+ M|18 session recordings on demand.

    Session highlights

    michaelhoward_keynote.jpg

    • The welcome keynote from MariaDB’s CEO, Michael Howard, announced several new initiatives, including MariaDB Labs, a research division focused on solving extreme challenges within the database industry on the topics of machine learning; distributed computing; and next-generation chips, storage and memory.
    • Corporate Banking and Future-Ready Technology,” with Ng Peng Khim and Joan Tay from DBS (Development Bank of Singapore), provided an update on the bank’s journey from Oracle Enterprise to MariaDB TX.
    • Massive Scale with MariaDB,” with ServiceNow’s Tim Yim, revealed that the company has a mind-blowing 85,000 MariaDB databases that ServiceNow manages with a custom “multi-instance deployment” implementation.
    • How We Made the Move to MariaDB at FNI,” with William Woods from Financial Network, Inc., shared the considerations, including security, that led FNI to migrate from Oracle to MariaDB.
    • MariaDB AX Panel Discussion on Analytical Use Cases,” featuring Aziz Vahora from Pinger, Jack Sprague from Center of Information Management, and Patrice Linel from Genus Plc., provided an opportunity to hear directly from MariaDB AX users from diverse industries and learn why they chose MariaDB.
    • How Facebook Migrated to MyRocks,” with Facebook’s Yoshinori Matsunobu, covered how Facebook created the MyRocks storage engine (which is in RC for MariaDB Server 10.3) to replace InnoDB in the Facebook users database, and highlighted MyRocks features being developed.
    • Panel Discussion: Open Source in the Enterprise,” featured Bill Montgomery of Red Hat, Dheeraj Golla of Copart, and Phil Mazza of Financial Network, Inc., sharing why they chose to adopt open source, the business and technical challenges they faced and how other enterprises can succeed with open source software.
    • How Copart Switched to MariaDB and Reduced Costs During Growth,” featured Dheeraj Golla and Pravin Malali of Copart explaining why Copart chose to standardize on MariaDB TX, how they convinced operational and development teams to adopt it, and how they’re now evaluating MariaDB AX as a replacement for their current analytics database.

    Networking with games

    Learning opportunities abounded at M|18, all while having fun. At the opening-night party and closing reception, attendees enjoyed food, drink and conversation – plus a little good-natured competition.

    MariaDBblocks.jpg

    pac-man.JPG

    airhockey.jpg

    #MARIADBM18

    Thanks to the attendees and speakers, M|18 was trending on Twitter. Here are a few of our favorite conference tweets.

    An extra thanks …

    … to our sponsors for their generous support.

    m18sponsors.png

    M|19 will be announced soon!

    MDBteam.jpg

    In the next few weeks, we’ll release the dates for our next MariaDB user conference, M|19. Be on the lookout for the announcement!

  • MariaDB MaxScale: Masking and Firewall

    To properly prevent some columns from being accessed, the masking filter that was introduced in MariaDB MaxScale 2.1 must be used together with the database firewall filter. In version 2.1, it was somewhat cumbersome to setup the database firewall filter for use together with the masking filter. With the recently released MariaDB MaxScale 2.2 (GA), we have introduced new features that makes the combined use of the masking filter and the database firewall filter much easier.

    Before moving to the new functionality introduced in version 2.2, let us recap what the masking filter actually can do. With the masking filter it is possible to mask the returned values, so that even though a column can be SELECTed, the actual value will not be revealed. This can be used for restricting access to some information without making the actual column inaccessible.

    For instance, suppose there is a table person that, among other columns, contains the column ssn where the social security number of a person is stored. With the masking filter it is possible to specify that when the ssn field is queried, a masked value is returned, unless the user making the query is a specific one.

    That is, when making the query

    > SELECT name, ssn FROM person;

    instead of getting the real result, as in

    +——-+————-+
    | name  | ssn         |
    +——-+————-+
    | Bob   | 435-22-3267 |
    | Alice | 721-07-4426 |

    the ssn would be masked, as in

    +——-+————-+
    | name  | ssn         |
    +——-+————-+
    | Bob   | XXX-XX-XXXX |
    | Alice | XXX-XX-XXXX |

    Taking masking into use is quite straightforward; in the service section it is referred to just like any other filter

    [TheService]
    type=service

    filters=Masking

    and at minimum the filter configuration looks as follows:

    [Masking]
    type=filter
    module=masking
    rules=path-to-masking-rules-file

    The value of the rules key is the path of the file containing the rules. The full documentation for the masking filter can be found here, so we will not cover all details but only the basics and what is new in MaxScale 2.2. The rules file used in the previous example looks as follows:

    {
    “rules”: [
    {
    “replace”: {
    “column”: “ssn”
    },
    “with”: {
    “value”: “XXX-XX-XXXX”
    }
    }
    ]
    }

    The content must be JSON object with a single key rules whose value is an array of rule objects. Each rule object can contain various keys, the most notable of which are replace and with. The value of replace tells what should be replaced and the value of with what it should be replaced with. So, above we specify that the value of a column called ssn should be replaced with the string “XXX-XX-XXXX”.

    The string specified with value is used to replace the actual value only if the length of the real value is exactly the same as the length of the string. If that is not the case, then the value will by default be replaced with as many “X”s as necessary. This is different from MaxScale 2.1, where the catch all string had to be specified using a fill key. The fill key can still be specified if some other string but “X” should be used.

    Note that with the above rules, the masking will be applied to all users, but with the key applies_to it can be specified what users are affected and with the key exempted what users are exempted, so it is straightforward to apply the masking to only a specific set of users.

    More Functionality

    Replacing the entire value with something else was the only option there was in MaxScale 2.1. In MaxScale 2.2 we have provided additional alternatives for how the value is replaced.

    Partial Replacement

    In MaxScale 2.2, it is no longer necessary to replace the entire value, but it is possible to replace only some part of it. Consider, for instance, the previous example where we masked the social security number entirely. If we would like to only mask the last 4 digits of the number it could be accomplished with the following rule.

    {
    “rules”: [
    {
    “replace”: {
    “column”: “ssn”,
    “match”: “….$”
    },
    “with”: {
    “value”: “YYYY”
    }
    }
    ]
    }

    With the match key a PCRE2 regular expression can be defined. If some part of the value matches that regular expression, then that and only that part is replaced. The string above matches the four last characters – whatever they are – so the last four characters will be masked.

    With partial matching, the string specified with value is used, provided the length of that string is exactly the same as the string matched by the regular expression. With these rules, the result looks as follows:

    +——-+————-+
    | name  | ssn         |
    +——-+————-+
    | Bob   | 435-22-YYYY |
    | Alice | 721-07-YYYY |

    Obfuscation

    Another feature introduced in MaxScale 2.2 is obfuscation. That is, instead of simply replacing a value with a fixed string, the value is replaced with a new value that is created from the original value, but in such a manner that the original value cannot easily be obtained from the generated one. Using obfuscation instead of replacement is easy; simply replace the replace keyword with obfuscate and remove the with object entirely.

    {
    “rules”: [
    {
    “obfuscate”: {
    “column”: “ssn”
    }
    }
    ]
    }

    And the result is as follows:

    +——-+————-+
    | name  | ssn         |
    +——-+————-+
    | Bob   | +|bv%~6d{y  |
    | Alice | ~H;Oj#Q~~( |

    Currently partial matching is not supported in conjunction with obfuscation but is always done to the entire value. Partial matching will be supported in the future.

    The obfuscation algorithm is basically a hashing function that in principle makes it impossible to obtain the original value from the obfuscated one. Note, however, that if the range of values is limited, it is straightforward to figure out the possible original values by running the full range of values through the obfuscation algorithm, thus obtaining a mapping from values to obfuscated values, and then comparing the result of the query with the values in that mapping.

    Note on function blocking and masking:

    The masking filter works only on the result set, which means it is easy to bypass it. Consider the following:

    > select name, ssn from person;
    +——-+————-+
    | name  | ssn         |
    +——-+————-+
    | Bob   | XXX-XX-XXXX |
    | Alice | XXX-XX-XXXX |
    +——-+————-+

    > select name, concat(ssn) from person;
    +——-+————-+
    | name  | concat(ssn) |
    +——-+————-+
    | Bob   | 435-22-3267 |
    | Alice | 721-07-4426 |
    +——-+————-+

    Simply by not using the column name as such, but “hiding” it in a function, means that the masking can be bypassed.

    Combining the Masking and Firewall Filters

    Preventing the bypassing of the masking filter using the firewall filter was possible already in MaxScale 2.1, but was quite awkward as the required firewall rules became quite extensive. Basically it was necessary to explicitly prevent the use of any function using which the masking could be bypassed. In MaxScale 2.2 we have provided additional firewall functionality using which the task becomes much easier.

    Starting with the service in the configuration file, the requests must first be passed through the firewall before they are provided to the masking filter.

    [TheService]
    type=service

    filters=Firewall|Masking

    And the firewall needs a section of its own.

    [Firewall]
    type=filter
    module=dbfwfilter
    rules=path-to-firewall-rules-file

    Then comes the firewall rules. What we want to prevent is the use of functions in conjunction with the column we want to mask. That can be accomplished using the following firewall rules.

    rule no_functions_with_ssn match uses_function ssn

    users %@% match any rules no_functions_with_ssn

    The rule above matches if the column ssn is used in conjunction with any function. If we now try to bypass the masking, the result will be as follows:

    > select name, concat(ssn) from person;

    ERROR 1141 (HY000): Access denied for user ‘cecil’@’127.0.0.1’ to database ‘testdb’: Permission denied to column ‘ssn’ with function.

    Every function cannot be used for bypassing the masking, so it is also possible to whitelist certain functions. For instance, if we want to allow the use of the function LENGTH, that can be accomplished as follows:

    rule only_length_with_ssn match not_function length columns ssn

    users %@% match any rules only_length_with_ssn

    This rule matches if the column ssn is used in conjunction with any other function but LENGTH. So, the following works

    > select name, length(ssn) from person;
    +——-+————-+
    | name  | length(ssn) |
    +——-+————-+
    | Bob   |          11 |
    | Alice |          11 |
    +——-+————-+

    but the use of any other function fails

    > select name, concat(ssn) from person;
    ERROR 1141 (HY000): Access denied for user ‘cecil’@’127.0.0.1’ to database ‘testdb’: Permission denied to column ‘ssn’ with function ‘concat’.

    Conclusion

    The masking and firewall filter can together be used for ensuring that unauthorized users cannot access the actual value of some column. In MariaDB MaxScale 2.2, the functionality of the firewall has been extended so that it is easy to prevent actions that otherwise could be used for bypassing the masking filter. Download MariaDB MaxScale now to get started.

  • Keynote Highlights from MariaDB’s M|18 User Conference

    M|18, the second annual MariaDB user conference, is in full swing, with more than 330 companies represented. The action kicked off today with a trio of live-streamed keynotes with themes ranging from the power of change and community to truly massive scale and future-ready technology. Take a look at the highlights:

    Dare to Be Different

    Michael Howard | MariaDB

    MariaDB’s CEO opened the show with the idea of global community as an agent of change – creating momentum, helping solve hard problems and making the future better.

    MichaelHoward.png

    Howard touched on MariaDB’s aim to make it easier for global enterprises to change and migrate, and announced the release candidate of MariaDB 10.3, which offers Oracle compatibility and more to ensure portability in terms of skill sets, not just code.

    Howard recognized that community is a vital part of continual innovation, and the role that MariaDB partners such as Google, Facebook, Intel, ServiceNow and the Development Bank of Singapore are playing in MariaDB’s growth. He highlighted MariaDB’s focus for the future, including:

    • MariaDB cloud and DBaaS offering. The first product to support this endeavor is MariaDB Manager—a visual interface allowing management and deployment of MariaDB.
    • MariaDB Labs, a new research division that brings together three key concepts:
      • Machine learning to intelligently determine your needs for storage, compute power and more.
      • Distributed computing with seamless write scalability.
      • Use of new chips, persistent storage, and in-memory processing, thanks to work with Intel. Howard envisions this recharging the conversation with regard to price point on public and private clouds.

    Massive Scale with MariaDB

    Tim Yim | ServiceNow

    85,000 databases around the world. Inside those, 176 million InnoDB tables, accessed at rate of 25 billion queries per hour. That’s the scale of ServiceNow’s business with MariaDB.

    Is this infrastructure multi-tenant or single-tenant? Neither! ServiceNow works with a new deployment model, “multi-instance deployment,” where each customer gets its own database and its own front-end app tier; there’s no commingling of data at all. This allows for “surgical failover” and scaling – one customer at a time.

    Every customer instance is running on bare metal, with hardware shared across the app tier and the database tier, but processes are “containerized.” Every piece of gear is also duplicated across the country, as is every customer app node and database. And each one of those is backed up nightly. That’s a lot going on! How did they achieve this?

    ServiceNow2.png

    All of the server instances to power this system are on MariaDB, and ServiceNow aims for five 9s availability – with hospitals, factories and power stations among ServiceNow’s clients, high availability is critical. But it’s more than that; the stability they get from MariaDB TX is also vital.

    Corporate Banking and Future-Ready Technology

    Ng Peng Khim and Joan Tay | DBS (Development Bank of Singapore)

    Khim and Tay covered the impressive results of DBS’s journey in “forklifting out” Oracle Enterprise, and replacing their institutional, transaction environments with MariaDB.

    DBSBank.png

    By moving to MariaDB, DBS has realized a net savings of $4.1 million from replatforming by removing the need for DB2 and Oracle Enterprise. Here’s a rundown of the impressive achievements in just two years:

    • 700+ MariaDB instances put in place
    • 54% of critical applications running on MariaDB – $70-80 billion in transactions daily
    • 100% increase in automated app releases
    • 10x increase in testing capabilities
    • 7x performance improvement from moving PL/SQL capability from Oracle to MariaDB

    In addition, MaxScale, MariaDB’s advanced database proxy, allows DBS to do quick schema changes to handle master/slave data replication, then do live verification—reducing downtime significantly.

    Keep up with all the M|18 action! Follow #MARIADBM18 on Twitter.

  • MariaDB Server 10.2.13 now available

    The MariaDB project is pleased to announce the immediate availability of MariaDB Server 10.2.13. See the release notes and changelog for details and visit staging-mdb.com/downloads to download.

    Download MariaDB Server 10.2.13

    Release Notes Changelog What is MariaDB 10.2?

  • Meltdown Vulnerability Impact On MariaDB Server

    Recent attacks, dubbed Meltdown and Spectre, have had a significant impact on various data processors and data security. In response, processors require modifications to the operating system; however, those modifications can be expensive and lead to potential slowdown in the applications and services. The following will explore the performance impact of the Meltdown workaround in the Linux kernel specific to MariaDB Server.

    Test Environment

    All tests were run on our benchmark machine: 2x 8 core Intel Xeon E5 v3 (Haswell) running Ubuntu Server LTS. We compared kernels 4.4.0-104 and 4.4.0-109. 4.4.0-104 is the last Ubuntu kernel in the 4.4.0 line without the KPTI patch. KPTI stands for Kernel Page Tabe Isolation and is meant as a remedy for the Meltdown attack.

    The benchmark is sysbench 1.0 OLTP in read-only and read/write mode. The MariaDB Server version used for this benchmark is MariaDB Server 10.2.11 (GA). MariaDB Server was running mostly with defaults. The InnoDB Buffer Pool was configured to large (all reads coming from memory). The durability was for production (flush-log-at-trx-commit=1). Storage in this machine is SSD.

    Since the performance often depends on the malloc implementation, a system function that allocates memory for the program, I ran two series of tests. One with the default glibc malloc and a second with tcmalloc (preloaded with the –malloc-lib option for mysqld_safe).

    Results

    The numbers shown below are queries per second. Note: higher is better.

    OLTP read-only

    glibc malloc

    tcmalloc

    threads

    4.4.0

    4.4.0 KPTI

    change

    4.4.0

    4.4.0 KPTI

    change

    1

    17111

    14894

    -12.96%

    16091

    16039

    -0.32%

    2

    31966

    28777

    -9.98%

    29426

    29396

    -0.10%

    4

    56142

    53817

    -4.14%

    54330

    56160

    +3.37%

    8

    109148

    107049

    -1.92%

    105223

    103910

    -1.25%

    16

    206156

    202927

    -1.57%

    206005

    204688

    -0.64%

    32

    279125

    259109

    -7.17%

    290233

    278157

    -4.16%

    64

    270800

    240219

    -11.29%

    290560

    281810

    -3.01%

    128

    259024

    226367

    -12.61%

    282176

    276145

    -2.14%

    256

    262552

    232061

    -11.61%

    284642

    277417

    -2.54%

    Screen Shot 2018-01-24 at 8.51.03 AM.png

    The impact of KPTI seems to be much higher at high concurrency. Tcmalloc delivers not only better results, but also the impact of KPTI is somewhat lessened.

    OLTP read/write

    glibc malloc

    tcmalloc

    threads

    4.4.0

    4.4.0 KPTI

    change

    4.4.0

    4.4.0 KPTI

    change

    1

    4706

    4584

    -2.59%

    4772

    4805

    +0.69%

    2

    9407

    9283

    -1.32%

    9620

    9515

    -1.09%

    4

    15912

    15860

    -0.33%

    16436

    15975

    -2.80%

    8

    30531

    29200

    -4.36%

    30786

    32298

    +4.91%

    16

    61954

    61102

    -1.38%

    63526

    63651

    +0.20%

    32

    126154

    121657

    -3.56%

    129561

    128284

    -0.99%

    64

    192459

    180334

    -6.30%

    198795

    195860

    -1.48%

    128

    220700

    200473

    -9.16%

    234564

    229417

    -2.19%

    256

    227077

    164281

    -27.65%

    241731

    235218

    -2.69%

    Screen Shot 2018-01-24 at 8.51.21 AM.png

    For read/write workload the KPTI impact is even higher at high thread counts. Again tcmalloc seems to deliver better results.

    Conclusion

    The Meltdown patch in the Linux kernel reduces the performance of MariaDB Server by 5% and, in some cases, more than 10%, depending on workload and concurrency. The performance impact is higher with high concurrency. In that case, it may help to try running MariaDB Server with a preloaded high-concurrency memory allocator like tcmalloc, jemalloc or other allocator of choice.

    Additional Resources

    There are some reports from third parties about KPTI regression for MySQL or general performance impact from Redhat that are worth reviewing. Their results are in line with what we found.

  • MariaDB Holiday Reflections and Gratitude

    As we wrap up 2017, we want to take a moment to reflect on the past year. We’ve seen tremendous support from our community, customers and partners – and for that, we are grateful. Our customers across the global have shared heartwarming stories of their business success and we appreciate the opportunity to be your valued partner.

    For us, 2017 was a milestone year. Our progress this year reflects a global theme that brings us forward to new opportunities.

    • Solutions to global problems: To make it easier for our customers to find solutions specific to their types of workloads, we introduced two complete solutions – MariaDB TX for transactional workloads and MariaDB AX for analytical workloads. The solutions are comprised of our technology products, as well as tools, services and support for an optimal production deployment environment. This year was also highlighted by the GA releases of MariaDB Server 10.2, MariaDB MaxScale 2.1, MariaDB ColumnStore 1.1.
    • Global event: In April, we held our first annual MariaDB global user conference M|17. Customer from as far away as Asia and Europe traveled to NYC to share success stories, best practices and technical deep dives from the MariaDB team.
    • Growing reach worldwide: This year, Debian followed the trend of Linux distributions replacing MySQL with MariaDB as the default. MariaDB reaches more than 60 million developers worldwide through its inclusion in every major Linux distribution, as well as a growing presence in the world’s major cloud providers.
    • Global team to support global customers: We’ve expanded our diverse team with employees in 20+ countries, plus Jon Bakke joined the leadership ranks as Chief Revenue Officer.
    • Investment from all corners of the world: Additional investment from Alibaba, the European Investment Bank and existing investors continue to fund global growth and product innovation.

    We are excited to keep up the momentum in 2018, starting with our second annual MariaDB M|18 user conference in February. We look forward to seeing you in NYC!

    Wishing you a happy new year from the team at MariaDB!

    Happy New Year | Onnellista uutta vuotta | Feliz año nuevo 

    Bonne année | Gott Nytt År | Felice Anno Nuovo

    Frohes neues Jahr | С Новым годом | 新年快乐 | 良いお年を | 새해 복 많이 받으세요