We’re pleased to announce that Joyent has some new investors. Weather Investment II and Telefonica Digital have together invested $85 million into Joyent. We’d like to welcome Weather II and it’s advising company Accelero, along with Telefonica Digital, to the Joyent family.

How will the new funds be spent, you may ask? Please read the press release here, and we’ll link to some of the stories that emerge today.

Photo by DonkeyHotey

Earlier this week you may have seen word from Corporate Vice President Scott Guthrie or the Interoperability Team at Microsoft, but today the Azure team released their announcement regarding Node on Windows Azure and the Windows Azure SDK for Node.js. After many months of hard work between the Azure team and the core team here at Joyent on the port of Node and npm, we’re seeing Node’s first appearance in Microsoft’s products. For Joyent and the Node community, this is yet another strong statement regarding the maturity and enterprise-readiness that Node has achieved. Providing a first-class experience for Node developers on Windows is like strapping space shuttle solid rocket boosters to a technology that was already shattering airspeed records for community growth and enthusiasm. You will have the opportunity to hear more about Node from Microsoft’s perspective from Scott Guthrie himself in late January at the Node Summit.

Ryan Dahl, Engineer at Joyent and creator of Node, also chimes in on the importance of this achievement.

We’re down in Santa Clara for the annual MongoSV show and simultaneously announcing the launch of our brand new SmartMachine for MongoDB. This new virtual machine comes pre-loaded with a fully tuned, optimized, and ready to deploy instance of MongoDB, the NoSQL database that is becoming a key player in mobile, e-commerce, game and other responsive, low-latency applications. The growth of the MongoDB community has been extremely rapid as more people have come to embrace NoSQL data stores for modern Web application and DIRTY (data-intensive, real-time) uses.

In discussions we also heard many devs talk about how MongoDB and Node.js (the application environment of which Joyent is a corporate steward) play so well together with javascript, JSON, and other nice matches that make mating the two ridiculously easy to pull off. MongoDB running on top of Joyent’s SmartOS SmartMachine brings a lot of additional goodies including:

• On-the-fly resizing of the database with no reboot or service interruption
• Bursting of up to 800% at not extra charge to keep the database responding smoothly, even under extreme loads
• DTrace-driven analytics for mapping latency outliers in four-dimensional heat maps rather than fighting through logs or staring at graphs or charts that hide the bad actors

And this is where Circonus comes in as a Joyent partner. Circonus provides organization-wide unified monitoring across a wide variety of critical parameters spanning an organization’s entire infrastructure constellation. In a nutshell, they make it much easier for ops teams to spot problems and monitor performance (They also work in partnership with another key Joyent Cloud partner, application and server monitoring service New Relic and the two services are quite complementary).

It’s all part of the growing DevOps ecosystem that we at Joyent see as a key piece of the future for cloud computing. (It also ties in with our own Cloud Analytics product for highly granular root cause analysis and application tuning- another complementary offering). So you’ll be hearing a lot about this from us going forward as the concept of DevOps continues to evolve and tools around it continue to evolve with it. Circonus is currently offering a special incentive to Joyent Cloud clients — the Circonus Copper plan free for a full 90 days. Joyent Cloud clients can take advantage of this promotion here – http://circonus.com/partners/joyent/sign-up. It’s a great deal and we are always open to any feedback you may have about our partner services. Thanks for reading!

Earlier today Joyent Founder and CTO Jason Hoffman and Isobe-san, CEO of Yahoo! Japan subsidiary First Server, announced the launch of First Server’s SmartDataCenter-powered public cloud service, named Z Cloud, at a press conference in Tokyo.

Isobe-san also unveiled First Server’s Node.js service, named Node Ninja, just in time for NodeFest (also known as 東京Node学園祭2011), a conference of Node.js developers in Japan.

Photo Credit Publickey Blog by Junichi Niino

We’re proud to introduce our cloud software customers today in this announcement. As you can see from the map above, our customers are spread across the globe. Despite the geographic diversity, at least one thing they have in common is their use of SmartDataCenter to provide cloud services to their customers.

Thank you ClusterTech, First Server, MiTAC Information Technology, NavLink, Uniserve, Libero, Servus, and AniseAsia, for using SmartDataCenter to provide the best available cloud software and services to your existing and future customers around the world.

We are pleased to welcome a new customer-partner to our global community of service providers running Joyent-powered clouds: NavLink.

NavLink is an AT&T affiliate based in the Middle East and providing managed Information Communication Technology (ICT), enterprise networking and cloud services to telecom operators and medium and large enterprises in over 17 countries throughout EMEA.

The folks at NavLink plan to use Joyent’s SmartDataCenter to provide their enterprise customers with public cloud services, and to license SmartDataCenter to their telecom customers throughout the region.

Welcome, NavLink! We look forward to working with you.

Read the full story here.

Don’t let the size fool you: MiCloud is built using the most modern, efficient, and performant hardware, software and networking available today. You can read more about what powers it here.

(That’s Jason, second from the left.)

For Joyent customers serving apps and games on Facebook, there may be several steps you need to take in addition to the authentication changes outlined above:

• All apps have to be served via HTTPS. Facebook apps can’t have segregated HTTP and HTTPS, so all apps may have to switch to encrypted protocols. Depending on whether you are running your Facebook application on one server, or a distributed architecture, the steps you need to take may be different.
• Generally, single server apps with moderate traffic loads won’t require any infrastructure changes. The extra processing load for SSL will be taken care of by the automatic CPU bursting offered on the Joyent Cloud.
• Applications with high I/O should consider increasing the SmartMachine size for a larger CPU allocation, or adding a Zeus Load Balancer and off-load SSL encryption/decryption.
• Customers who are already using our Zeus ZXTM traffic controller solution can handle the implementation of SSL across their all of their web servers from one centralized console and SSL management source. This mitigates the need to add compute nodes or capacity. The documentation on the Zeus website is fairly easy to follow.
• If you don’t have an SSL certificate, there are many vendors that sell secure certificates and have instructions on how to enable SSL on your app/website. There are no IP space changes involved – you just have to ensure that the SSL certificates match your domain names. Also traffic will flow to port 443 rather than port 80 and SSL certificates add an extra encryption/decryption process to all I/O.
• If you have media assets or objects stored separately on edge services like a CDN (Content Distribution Network), you may have to use a CDN SSL service so you don’t serve mixed SSL/non-SSL pages. Contact your CDN administrator for more information and to discuss the requirement and pricing.
• To simplify cross-browser compatibility, consider ending support for browsers with older security protocols, such as anything older than IE 7.x, Firefox 5.x and Safari 3.x

If you’re still unclear how to do prepare for the upcoming Facebook changes or need a little help, just file a request with support@joyent.com.

EDITOR’S NOTE: One more link on the Facebook Forums regarding SSL Certificates that may be useful.

By Bryan Cantrill

A little over a year ago, I came to Joyent because of a shared belief that systems software innovation matters — that there is no level of the software stack that should be considered off-limits to innovation. Specifically, we ardently believe in innovating in the operating system itself — that extending and leveraging technologies like OS virtualization, DTrace and ZFS can allow one to build unique, differentiated value further up the software stack. My arrival at Joyent also coincided with the birth of illumos, an effort that Joyent was thrilled to support, as we saw that rephrasing our SmartOS as an illumos derivative would allow us to engage in a truly open community with whom we could collaborate and collectively innovate.

In terms of the OS technology itself, as powerful as OS virtualization, DTrace and ZFS are, there was clearly a missing piece to the puzzle: hardware virtualization. In particular, with advances in microprocessor technology over the last five years (and specifically with the introduction of technologies like Intel’s VT-x), one could (in principle, anyway) much more easily build highly performing hardware virtualization. The technology was out there: Fabrice Bellard‘s cross-platform QEMU had been extended to utilize the new microprocessor support by Avi Kivity and his team with their Linux kernel virtual machine (KVM).

In the fall of last year, the imperative became clear: we needed to port KVM to SmartOS. This notion is almost an oxymoron, as KVM is not “portable” in any traditional sense: it interfaces between QEMU, Linux and the hardware with (rightful) disregard for other systems. And as KVM makes heavy use of Linux-specific facilities that don’t necessarily have clean analogs in other systems, the only way to fully scope the work was to start it in earnest. However, we knew that just getting it to compile in any meaningful form would take significant effort, and with our team still ramping up and with lots of work to do elsewhere, the reality was that this would have to start as a small project. Fortunately, Joyent kernel internals veteran Max Bruning was up to the task, and late last year, he copied the KVM bits from the stable Linux 2.6.34 source, took out a sharpened machete, and started whacking back jungle…

Through the winter holidays and early spring (and when he wasn’t dispatched on other urgent tasks), Max made steady progress — but it was clear that the problem was even more grueling than we had anticipated: because KVM is so tightly integrated into the Linux kernel, it was difficult to determine dependencies — and hard to know when to pull in the Linux implementation of a particular facility or function versus writing our own or making a call to the illumos equivalent (if any). By the middle of March, we were able to execute three instructions in a virtual machine before taking an unresolved EPT violation. To the uninitiated, this might sound pathetic — but it meant that a tremendous amount of software and hardware were working properly. Shortly thereafter, with the EPT problem fixed, the virtual machine would happily run indefinitely — but clearly not making any progress booting. But with this milestone, Max had gotten to the point where the work could be more realistically parallelized, and we had gotten to the point as a team and a product where we could dedicate more engineers to this work. In short, it was time to add to the KVM effort — and Robert Mustacchi and I roped up and joined Max in the depths of KVM.

With three of us on the project and with the project now more parallelizable, the pace accelerated, and in particular we could focus on tooling: we added an mdb dmod to help us debug, 16-bit disassembler support that was essential for us to crack the case on the looping in real-mode, and DTrace support for reading the VMCS. (And we even learned some surprising things about GNU C along the way!) On April 18th, we finally broke through into daylight: we were able to boot into KMDB running on a SmartOS guest! The pace quickened again, as we now had the ability to interactively ascertain state as seen by the guest and much more quickly debug issues. Over the next month (and after many intensive debugging sessions), we were able to boot Windows, Linux, FreeBSD, HaikuOS, QNX, Plan 9 and every other OS we could get our hands on; by May 13th, we were ready to send the company-wide “hello world” mail that has been the hallmark of bringup teams since time immemorial.

The wind was now firmly at our backs, but there was still much work to be done: we needed to get configurations working with large numbers of VCPUs, with many VMs, over long periods of time and significant stress and so on. Over the course of the next few months, the bugs became rarer and rarer (if nastier!), and we were able to validate that performance was on par with Linux KVM — to the point that today we feel confident releasing illumos KVM to the greater community!

In terms of starting points, if you just want to take it for a spin, grab a SmartOS live image ISO. If you’re interested in the source, check out the illumos-kvm github repo for the KVM driver itself, the illumos-kvm-cmd github repo for our QEMU 0.14.1 tree, and illumos itself for some of our KVM-specific tooling.

One final point of validation: when we went to integrate these changes into illumos, we wanted to be sure that they built cleanly in a non-SmartOS (that is, stock illumos) environment. However, we couldn’t dedicate a machine for the activity, so we (of course) installed OpenIndiana running as a KVM guest on SmartOS and cranked the build to verify our KVM deltas! As engineers, we all endeavor to build useful things, and with KVM on illumos, we can assert with absolute confidence that we’ve hit that mark!