Microsoft has worked with the Eclipse community for many years and we joined the Eclipse Foundation in 2016. Today I'm excited to share Microsoft is continuing to advance our support of the Eclipse Foundation AISBL by expanding our participation to a Strategic Member. I will also be joining the Foundation's board of directors and I look forward to working alongside our industry partners.

The Eclipse Foundation has a long history of providing a strong, collaborative culture supporting open-source-licensed projects, and many of those projects are important to Microsoft, our partners, and our customers. It is important for Microsoft to support the organization that supports those projects, and to work within the organization towards those collective goals.

Collaboration in community

The Eclipse Foundation has deep expertise in vendor-neutral governance, infrastructure, marketing, community building, and developer advocacy work. The team showed initiative and forethought, and pivoted to become a European-based international non-profit organization to align with its membership. The Eclipse Foundation is a natural place for Microsoft to collaborate on new initiatives beginning with European partners.

The Eclipse Foundation remains a vital cornerstone of the Java ecosystem. Microsoft is committed to Java developers and the health of the Java ecosystem, actively participating in Eclipse Adoptium (formerly AdoptOpenJDK) and other projects. Expanding our involvement with the Foundation as a Strategic Member will help advance modern Java initiatives in the spirit of open source.

The Eclipse Foundation also has close ties with core parts of the Java community with the Eclipse IDE, Jakarta EE (the successor to Java EE), and MicroProfile projects hosted there. For Microsoft and its partners, the Eclipse Foundation was the logical choice for AdoptOpenJDK to continue that mission. As a vendor-neutral, multi-vendor initiative, Eclipse Adoptium continues to be a leading provider of fully compatible, high-quality distributions of Java runtimes based on OpenJDK source code.

The Eclipse Foundation is expanding its role through working groups and many of these working groups are important to Microsoft and its partners. Recent work around the Eclipse Dataspace Connector and Eclipse Tractus-X are examples of new work beginning at the Eclipse Foundation in working groups in which Microsoft has an interest in participating.

Looking ahead

Open source non-profits serve an important role in the community, providing the structure to enable projects to reach their next opportunity of growth. Companies support such non-profits because it supports their engagement in the non-profit's projects, supports relationships with collaborating partners, and supports the developer communities at large. Having a rich ecosystem of healthy non-profits supporting different groups of Open-Source-Initiative-licensed projects and their project ecosystems is a must. At Microsoft, we are committed to continuing to support and participate across the non-profit ecosystem, as well as engage in projects themselves.

The post Microsoft expands support with The Eclipse Foundation appeared first on Microsoft Open Source Blog.

Learn more about the preview release and Java at Microsoft in the full announcement blog.

Visit Microsoft build of OpenJDK page to download packages and installers.

The post Announcing preview of Microsoft build of OpenJDK for Java 11 appeared first on Microsoft Open Source Blog.

We are working with key industry partners like Oracle, IBM, Red Hat, and Payara to better support runtimes, including WebLogic, WebSphere Traditional, Open/WebSphere Liberty, JBoss EAP, WildFly, and Payara on Microsoft Azure.

Some currently available and recent examples of this work include:

• Enabling most use cases for WebLogic on Microsoft Azure Virtual Machines through a set of solutions jointly developed and supported with Oracle.
• Guidance for integrating WebSphere/Open Liberty with Azure Active Directory via OpenID Connect developed in collaboration with IBM.
• Public preview for JBoss EAP on App Service, jointly supported by Microsoft and Red Hat.
• Preview for supporting JMS on Azure Service Bus.
• Guidance for migrating to WildFly on AKS.

Work items upcoming shortly as part of our Java EE on Microsoft Azure customer outreach include:

• Enabling WebLogic on AKS in partnership with Oracle.
• Guidance for running WebSphere/Open Liberty applications on Azure Red Hat OpenShift, developed in collaboration with IBM.
• Enabling JBoss EAP on Virtual Machines, in collaboration with Red Hat.

We hope to fully enable Java EE customers as first-class citizens on Microsoft Azure through these efforts steadily.

There is no substitute to working closely, one-on-one with actual users. Solutions developed in a vacuum are rarely on-point. The ideal is to get real-world, experience-based feedback on the solutions we provide as we develop and release them iteratively.

We're looking for Java EE users and customers who will work closely with the Microsoft team responsible for developing these solutions. If desired, Microsoft is hoping to help some customers with a free migration proof-of-concept. If this sounds interesting, please fill out this 5-minute survey.

The survey attempts to better understand the common use cases we need to support in order to help customers realize all the benefits of the cloud. If you would like the team to connect with you directly, please include your contact information at the end. Even if you are not necessarily interested in migrating to Microsoft Azure right now, your feedback on what you would like to see is still very valuable.

Also, if you know someone who would like to participate, please forward the survey link. Looking forward to hearing from you!

Take the 5-minute survey.

Questions about the survey? Please let us know in the comments below.

The post Participate in the Java EE cloud migration patterns survey appeared first on Microsoft Open Source Blog.

Java has a rich history in enterprise applications and has evolved over the past two decades to encompass a rich ecosystem with open source projects, open standards, innovation by individuals,and start-ups and companies of all sizes. With the maturity of cloud computing, advancements such as automated operations for hybrid and multi-cloud are needed more now than ever before. Kubernetes is top of mind to many for migrating traditional on-premises deployment to the cloud. There’s a tradeoff, however, around new platforms, methodology, best practices, budgetary considerations, and modernization options to name a few. Great, so what’s next?

The J4K conference was conceived to help folks navigate their way through a mix of options. J4K is running four tracks to help developers enrich their experiences and skillsets. The 2020 session tracks are:

• Application on cloud, containers, and K8s (real-life examples)

• Frameworks and architectures on cloud, containers, and K8s

• Developer tools for cloud, containers, and K8s

• Practices and other technologies

There will be 50 exciting sessions, including a keynote by Red Hat VP of Engineering, Mark Little, and Microsoft CVP of Azure Engineering, Brendan Burns. To welcome the community and make you feel at home, we have Heather VanCura, Chairperson and Director of the Java Community Process (JCP), and Josh Long, Spring Developer Advocate at VMWare. Because it’s 2020 and in-person conferences are of the past in this strange new world, you shouldn’t miss a beat in personal growth and community fun. Join J4K with Microsoft to help us celebrate and move Java on Kubernetes forward for all.

Check out Microsoft’s keynote and sessions:

Building portable cloud-native applications with Java, Kubernetes, and dapr.io

Keynote by Brendan Burns | Wednesday, Oct 14, 2020 | 9:00 AM – 9:45 AM

Which as-a-Service is right for your Java apps?

Session by Christina Compy and Theresa Nguyen | Wednesday, Oct 14, 2020 | 3:00 PM – 3:45 PM

Memory Efficient Java

Session by Kirk Pepperdine | Tuesday, Oct 13, 2020 | 4:00 PM – 4:45 PM

The Diabolical Developer’s Guide to Picking Your Java

Session by Martijn Verburg | Wednesday, Oct 14, 2020 | 1:00 PM – 1:45 PM

Run Spring Microservices at Enterprise Scale – Azure Spring Cloud

Session by Asir Vedamuthu Selvasingh | Tuesday, Oct 13, 2020 | 4:00 PM – 4:45 PM

We’ll also have a community leaderboard, photo, poll questions, andcontests during the event with prizes, in addition to other exciting opportunities to win. Join us today by registering for J4Kand feed your brain with Java and Kubernetes goodness. See you next month!

Helpful links:

• JBoss EAP on App Service Linux (in preview)
• Register for J4K
• J4K 2020 Edition virtual conference video

The post J4K: an all-star Java and Kubernetes speaker line-up in one conference  appeared first on Microsoft Open Source Blog.

Announcements during the keynote

We're excited to share new groundbreaking Azure features that will help you run your Spring applications the only way they should: in a very cloud-native way! These announcements will be highlighted during SpringOne's keynote on Tuesday morning at 9am CT, with Microsoft and Pivotal together on stage giving you all the details and providing you with a live demo.

Breakout sessions

After the keynote, there will be two joint Microsoft/Pivotal deep-dive conference sessions on how to run Spring Boot on Azure with these new features.

Julien Dubois (Microsoft) and Josh Long (Pivotal) will do a live-coding session labeled "Running Spring Boot Applications Efficiently on Azure" where they will start from start.spring.io and take you on a journey to production (the best place on earth, according to Josh!) using Azure. As they use a microservice architecture, they will detail how you can benefit from Azure's unique features to deploy, scale, and monitor your Spring Boot components, and how the new reactive programming model championed by Spring helps to have better scalability and performance.

Running Spring Boot Applications Efficiently on Azure
Wednesday 3:20pm3:50pm in Ballroom D

Asir Selvasingh (Microsoft), Richard Seroter (Pivotal) and Vaibhav Agrawal (Best Buy) will get together to detail the right way to use Microsoft Azure with your Spring apps. In this session, you will get the latest news on the Azure Spring Boot starters and learn more about connectivity between your app and the many services provided by Microsoft.

Spring Data to Spring Cloud to Spring Security: How Azure Supercharges Spring Boot
Wednesday 11:30am12:40pm in Ballroom G

.NET expands at SpringOne

The presence of .NET speakers and content shouldn't surprise you either. This year, there are exactly 10 sessions from speakers from different companies like VMWare, Confluent, Magenic Technologies, Fiserv, and of course Pivotal and Microsoft, showcasing their use of .NET Framework, Steeltoe and other cloud-native technologies for the .NET developers attending the conference.

We have two in particular for your consideration, but make sure you visit the session catalog and filter by the ".net" tag to find all the other eight great presentations.

.NET Application Modernization with PAS and Azure DevOps
Thursday 12:30pm1:30pm in Room 8CD

Putting Pivotal Platform to the Hybrid Cloud Test: Azure
Wednesday 4:20pm5:30pm in Room 8AB

During the whole conference, the Azure engineering team together with product managers and developer advocates, will be present at the Microsoft booth to demonstrate all you need to know about Spring on Azure: don't hesitate to come and ask questions.

We wish you a great show, and hope to see you there.

The post Unboxing new Microsoft Azure solutions at SpringOne Platform 2019 appeared first on Microsoft Open Source Blog.

With the power of Ansible and Jenkins, and their deep integration with Azure, you can have a seamless CI/CD experience on Azure. Below is an example for a web app scenario. Jenkins is used to build and deploy, and Ansible is called to handle provisioning.

In the following sections, we will walk though how to use Jenkins to call Ansible to provision a web app and then continuously build and deploy a Java Spring Boot application to Azure Web Apps.

Build your Jenkins and Ansible environment

Set up the Jenkins host

It is easy to create a Jenkins server on an Azure Linux virtual machine from a solution template. You can learn more about this template from install-jenkins-solution-template.

Install Ansible on the Jenkins host

When your Jenkins host is created, let us SSH to your Jenkins server and set up Ansible on it.

## Install pre-requisite packages

$ sudo apt-get update$ sudo apt-get install -y libssl-dev libffi-dev python-dev python-pip

## Install Ansible and Azure SDKs via pip

$ sudo pip install ansible[azure]==2.7.0rc2

or
## Install Azure preview modules

$ sudo ansible-galaxy install Azure.azure_preview_modules$ sudo pip install -r ~/.ansible/roles/Azure.azure_preview_modules/files/requirements-azure.txt

Note: Ansible modules for Azure Web Apps are only available in Ansible 2.7. You could install Ansible 2.7 RC version here or install Azure role named azure_preview_modules which include latest modules. Ansible 2.7 will be released on Oct 4^th. After that, you need not specify the version here because the default version will be 2.7.

Install Maven for a sample Java application

In this demo, we will directly use this Jenkins server to build our Java application. Here we also install Maven on it.

## Install maven

sudo apt-get install -y maven

Install Jenkins plugin for Ansible

The following three plugins will be used for this web app scenario.

• azure-app-service: A Jenkins plugin to deploy a web app.
• ansible: This plugin allows to execute Ansible tasks as a job build step.
• envinject: This plugin makes it possible to have an isolated environment for your jobs.

Connect to your Jenkins server by following connect-to-jenkins. After you unblock Jenkins, suggest you choose “Install suggested plugins.” The Jenkins plugin for App Service will be installed here.

To install the other two plugins, click “Manage Jenkins“ on the left bar and select “Manage Plugins.” Select “Available” tab, search and install Ansible plugin and Environment Injector plugin.

Prepare Application, Ansible playbook, and Jenkinsfile

Spring Boot application for Azure Web Apps

Here we forked a Spring Boot project from https://github.com/spring-guides/gs-spring-boot to https://github.com/VSChina/gs-spring-boot for the following tutorial. On the branch named”war-based-deployment,” we updated the application.java and pom.xml to package this project as an executable war file, which can be directly deployed to Azure Web Apps with a Tomcat container by default.

Ansible playbook to provision Azure Web Apps

The below Ansible playbook creates a resource group and a web app on App Service Linux with Java 8 with Tomcat container runtime.

- name: Create Azure VM hosts: localhost connection: local vars: resource_group: "{{ lookup('env', 'RES_GROUP') }}" webapp_name: "{{ lookup('env', 'WEB_APP_NAME') }}" location: eastus tasks: - name: Create a resource group azure_rm_resourcegroup: name: "{{ resource_group }}" location: "{{ location }}" - name: Create a linux web app with java framework azure_rm_webapp: resource_group: "{{ resource_group }}" name: "{{ webapp_name }}" plan: resource_group: "{{ resource_group }}" name: myappplan is_linux: true sku: S1 number_of_workers: 1 frameworks: - name: "java" version: "8" settings: java_container: tomcat java_container_version: 8.5

Jenkinsfile

Below Jenkinsfile defines 4 tasks as followings.

1. Check out source code
2. Build
3. Call Ansible to provision web app
4. Deploy application to created web app

node { stage('Init') { checkout scm } stage('Build') { sh ''' cd complete mvn clean package mv target/*.war ROOT.war ''' } stage('Deploy') { withCredentials([azureServicePrincipal(credentialsId: env.AZURE_CRED_ID, subscriptionIdVariable: 'AZURE_SUBSCRIPTION_ID', clientIdVariable: 'AZURE_CLIENT_ID', clientSecretVariable: 'AZURE_SECRET', tenantIdVariable: 'AZURE_TENANT')]) { ansiblePlaybook installation: 'ansible', playbook: 'complete/deploy/ansible/webapp.yml' } azureWebAppPublish azureCredentialsId: env.AZURE_CRED_ID, resourceGroup: env.RES_GROUP, appName: env.WEB_APP_NAME, filePath: "ROOT.war" }}

Define your Jenkins pipeline

Add Azure Service Principal in credentials

Authentication is required using Ansible modules to provision Azure resources. If you don't have Service Principal, create an Azure service principal. Take note of the values for the subscription ID, Client ID, Secret, and Tenant ID.

On Jenkins dashboard, click Credentials on the left bar and then System item. Then you will see Global Credentials on the page. Select it and click Add Credentials. As for kind, select Microsoft Azure Service Principal here and fill in subscription ID, Client ID, Secret, and Tenant ID.

After you click ok, you will see a new item is added. Copy the name (here it is 542d982a-7614-4a3d-ae6b-ce321bfef5b0) which is your <azure-credentials-id>.

Create a Jenkins job

Select New Item from the Jenkins console, then fill in your project and select Pipeline project, then select OK.

In General section, select Prepare an environment for the run. In the Properties Content, fill in following content.

AZURE_CRED_ID=azure-credentials-idWEB_APP_NAME=web-app-nameRES_GROUP=web-app-resource-groupJENKINS_ADMIN=Jenkins-server-username

In Pipeline section, select Git for Source Control Management, fill in `https://github.com/VSChina/gs-spring-boot.git` in Repository URL and change Branch Specifier to “*/war-based-deployment“. As for Script Path, fill in “complete/deploy/jenkins/jenkinsfile-ansible-webapp.”

Launch the Jenkins Job

Now it is time to click Build Now. After the deployment is complete, you can find your web app on the portal and you will see it at https://<web-app-name>.azurewebsites.net.

Conclusion

In this tutorial we demonstrated a simple flow that automates web app provisioning and application deployment to Azure Web Apps. If you want to try more with the combination of Jenkins and Ansible, check out Ansible on Azure and Jenkins on Azure.

Questions? Let us know in the comments.

The post Tutorial: Automate infrastructure and deployment on Azure using Jenkins and Ansible appeared first on Microsoft Open Source Blog.

One of our favorite things to do at awesome developer conferences is to announce the latest developments for developers. At SpringOne, we will unveil new tools and services, including several new releases and Java support for Azure cloud services. Come by our booth and check out these demos:

1. Java on Azure and Azure Stack
2. Spring Boot apps & Spring Cloud Azure modules
3. Cloud Foundry on Azure with OSBA
4. Java monitoring with Application Insight

Azure App Service on Linux for web applications

This service is the easiest and fastest way to get started with your web applications on Azure. On top of enhancements to the service, we will be releasing the following updates:

5. Enhanced Apache Maven Plugin
6. Enhancements to Azure Toolkits for Eclipse and IntelliJ IDEs

Azure Service Fabric Mesh

Service Fabric Mesh is the serverless microservices platform in Azure. It is a fully managed Service Fabric environment that abstracts away all infrastructure including VMs, storage, orchestration and networking. Service Fabric Mesh allows developers to innovate on their business logic and build mission-critical microservice applications that can run side-by-side with lift-and-shift workloads.

For Java applications, product updates and releases:

7. JCache API support on Reliable Collections: Service Fabric Reliable Collections can be used as a library anywhere, and when you run it on a Service Fabric cluster, your cache becomes highly available through transparent replication (while providing you co-location of compute and data for low-latency workloads).
8. Apache Maven plugin: Easily create, build and deploy Java applications on Service Fabric Mesh

Azure Dev Spaces for Azure Kubernetes Service (AKS) Public Preview

Azure Dev Spaces provides a rapid, iterative Kubernetes development experience for Java development teams. With minimal dev machine setup, you can interactively run and debug Java containers directly in AKS. You can also collaborate with your team in a shared Kubernetes cluster, or integrate with your CI/CD pipeline, for end-to-end testing with other components without replicating or mocking up dependencies. To get started, check out the Quickstart for Java.

Presentations at SpringOne Platform

Other Microsoft engineers and I will be present at the conference to deliver these updates and other topics of interest to attendees. Sessions to check out and add to your schedule:

9. Building Responsive Systems with Serverless, Event-driven Java
10. Running Serverless Applications Using Spring and Microsoft Azure
11. Going Cloud-Native with Spring Cloud Azure
12. Hacking Spring Boot Applications Using Visual Studio Code
13. Beyond Windows Hacking Cloud Apps on Linux and .NET for the Busy Java Developer

Stop by and chat with us in the exhibition hall at booth #8 and come discuss any of these 13 things and check out our demos on Pivotal Cloud Foundry on Azure, Azure Application Insights, Spring tooling support, Open Service Broker API, Azure Stack, and much more! Of course, grab some swag when you stop by too.

Finally, don't miss out my presentation on Wednesday's main stage keynote, at 10am. I hope you will enjoy it.

See you soon!

The post 13 things to look for at SpringOne Platform appeared first on Microsoft Open Source Blog.

From October 8^th to 19^th, we will be joining Java User Groups to demonstrate how Java and Spring developers can bring Reactive Spring Boot applications to the cloud. We have nine stops, starting in the great city of Dublin, Ireland strategically chosen as the first stop, because we are all humans who deserve good beer to kick off such event. And, if our plane, train, and demo gods help us out, we will travel all the way to Bern, Switzerland, with seven stops in between.

Follow these folks on Twitter to keep up to date!

We will be presenting the two sessions, “Going Reactive with Spring Boot” and “Taking Spring Apps for a spin on the Microsoft Azure Cloud,” in addition to recapping the major news from both Microsoft's and Pivotal's recent conferences.

In these talks, we will cover topics like Spring Boot, Project Reactor, development of Java applications with Visual Studio Code, deployment to Microsoft Azure, and much more.

Check out the schedule below and where to register to attend these events!

European JUG Schedule

Finally, we'd like to thank all the JUG and community leaders who have helped us plan this tour. A big shout out to Barry Alistair (DubJug), Dominique Carlo (LJC), Julien Dubois (JHipster), Olivier Hubaut (BruJUG), Bert Jan Schrijver (Utrecht JUG), Tom Hombergs (Dortmund JUG), Alexander Culum (Frankfurt JUG), Thomas Darimont (JUGSaar), and finally Oliver Nautsch and Thomas Wenger (Switzerland JUG). Also a big thank you to Rabobank for sponsoring the event in Utrecht, Netherlands, and Ippontech for sponsoring the JHipster meetup in Paris.

See you in October, Europe!

The post Join Pivotal and Microsoft for the European JUG Tour appeared first on Microsoft Open Source Blog.

Our favorite photographer Julian Cash, who has become an OSCON tradition, will be capturing the many personalities of OSCON in the booth, so be sure to stop by and get a pic. You can also score a comicbook-style t-shirt, inspired by Julian’s OSCON photography, by completing one of our hands-on labs, including new labs featuring Blockchain on Azure or how to get started with OpenShift Origin.
Of course, the booth will be busy with engineers and dev advocates demonstrating new technologies and their favorite open source tools. Below are some of the demos you can check out:

• Developer Tools on Containers with @listonb@BerndVerst: Learn how to get started using containers with open source tools like Helm and Draft.
• Infrastructure as Code with @mekenthompson@zdeptawa: Automate provisioning and configuration of environments using Infrastructure as Code, using tools like Terraform or Ansible.
• Java and Azure Functions with @ruthieyakubu@sbohlen@andybeach: Tutorial on data anomaly detection using serverless computing and AI.
• Linux on Windows with @tara_msft@avneet723@auchenberg: See how developers can use their Linux development toolchain on Windows, with technologies like the Windows Subsystem for Linux (WSL).
• DevOps CI/CD with@mekenthompson@ethomson@dstaheli: Learn how to take advantage of continuous integration to improve software development quality and speed. See how Visual Studio Team Services integrates into existing toolchains, like Jenkins and GitHub.
• SQL Server on Linux with @spboyer: Walk through SQL Server's support for Linux and Docker containers.

In addition to catching up in the Expo, below is a rundown of the Microsoft breakout sessions throughout the week, covering topics from Kubernetes 101 and how to design distributed systems to the historic profiles of open source heros and a live keynote coding challenge.
Follow us @OpenAtMicrosoft to get the latest updates.

MONDAY, JULY 16^TH

.NET Core 2.0: From acquisition to containers (9am Noon) @spboyer
Hands-on overview of .NET Core 2.0 with Shayne Boyer. Whether you prefer a command line, a simple editor, or a full IDE, you'll learn how to get the bits, create console applications, and do cross-platform targeting. You'll also explore ASP.NET Core web development and .NET Core application tools and deployment.

TUESDAY, JULY 17^TH

Model validation: When things blow up (2:00pm2:30pm) @DynamicWebPaige
Machine learning offers a powerful toolkit for building complex predictive systems. These models can provide immense business value and are often deployed in high-consequence environments, but it can be extremely dangerous to think of those quick wins as coming for free. Paige Bailey explains what happens when your data changes over time and fresh models must be produced continuously and details the consequences of having your model's predictions go awry.
Kubernetes 101 (9:00am12:30pm) @bridgetkromhout
It is a truth universally acknowledged that a techie in possession of any production code whatsoever must be in want of a container orchestration platform. What's up for debate, according to noted thought leader Jane Austen, is how many pizzas the team is going to eat. In this hands-on Kubernetes workshop, Bridget Kromhout walks you through launching clusters and details all the moving parts you need to know about how to use Kubernetes in production. If you're into dev or ops or some portmanteau thereof, this is relevant to your interests.

WEDNESDAY, JULY 18^TH

Live coding: OSCON edition (Keynote, 9:05am 9:15am) @noopkat
Live coding sounds really scary, but it's a fear worth conquering. To show how fun it can really be, Suz Hinton rolls the dice and live-codes an entertaining hardware solution in front of your eyes. To make things interesting, she'll start with some randomly assigned inputs and outputs. The challenge is to have a working set of code inside 10 minutes that completes the assigned mission. Join in to find out if Suz has what it takes.
Heroic and inspiring tales of open source (11:00am11:40am) @stephenrwalli@DivaDanese
Twenty years in, open source represents one of the longest human experiments in global collaboration and change, and there are important lessons to be learned from this history. Danese Cooper and Stephen Walli explain why studying the history of open source will help the next generation of FOSS practitioners move forward with more confidenceand keep them from repeating past mistakes. This talk is meant as a gift to those who will inherit the open source movement, so they won't compromise open source out of existence.
DevOps with Kubernetes and Helm (11:50am12:30pm) @jldeen
Helm is a tool that streamlines installing and managing Kubernetes applications; it's like Homebrew for Kubernetes, but it's also so much more. Jessica Deen shows you how to use standard DevOps practices such as IaC, CI/CD, and automated release in conjunction with Kubernetes (AKS) and Helm. You'll learn how key DevOps practices tie right into container orchestration with Kubernetes and Helm and explore a live demo showcasing how to get started with Kubernetes by deploying a Go app through a full CI/CD pipeline using a preconfigured Helm chart.
Designing distributed systems: Patterns and practices for reliable software systems (11:00am11:40am) @brendandburns
Nearly every application now built is a distributed system, and these systems are expected to be reliable, dynamically updatable, and scalable to any load. However, though thousands of distributed systems are activated every day, designing and building them is more black art than science. The good news is that the study of such systems reveals a collection of repeated patterns and practices that can be applied to quickly construct reliable systems. Brendan Burns describes these patterns and explains how they can be used with the Kubernetes container orchestrator.
Building event-driven pipelines with Brigade (5:05pm5:45pm) @LachlanEvenson
Building complex or even simple event-driven pipelines on Kubernetes has always been somewhat of an elusive taskuntil now. Enter Brigade, a lightweight open source event-driven tool that accepts a JavaScript expression of a pipeline that gets seamlessly converted into the associated Kubernetes runtime objects. Lachlan Evenson demonstrates how to build event-driven pipelines on Kubernetes, showing just how simple it is to solve sometimes-complex tasks with Brigade.
TypeScript: Rethinking type systems with JavaScript (5:05pm5:45pm) @drosenwasser
Conventional wisdom says building a type system goes hand in hand with building a language. What happens when you go against convention? Well, for a language with millions of users like JavaScript, it turns out that your type system has to be pretty expressive. A language that builds on top of an existing language doesn't have the conveniences of allowing specific patterns but instead has to take the approach of understanding existing patterns. Daniel Rosenwasser explains how TypeScript has grown to meet JavaScript code and why it's one of the fastest growing languages today.

THURSDAY, JULY 19^TH

Distributed systems for stream processing: Apache Kafka and Spark Streaming (11am 11:40am) @lenadroid
Everything is a data source, and today's online activities, financial operations, and IoT devices and sensors generate data at an ever-increasing rate. So how do we ingest, process, and manage that data? We need an architecture to ingest these incoming influxes of data that is flexible, scalable, fast, and resilient. Alena Hall walks you through setting up and building a distributed streaming architecture on Azure using open source frameworks like Apache Kafka and Spark Streaming.
Deploying Linux to the cloud (2:35pm3:15pm) @bureado
Whether enabling large scale-out clusters, working at the heart of complex container-based architectures, or powering massive data solutions, Linux's flexibility, composability, and robustness have made it the bread-and-butter of the cloud. But the cloud is also changing how we make Linux happen, such as new ways of packaging and distributing software, building and maintaining clusters, leveraging economies of scale for storage and networking, and, maybe most importantly, observing, controlling, and managing this sprawling Linux infrastructure. Join Jose Miguel Parrella to explore these changes with regard to networking, high availability and clustering, security and management, and application operations and governance.

The post Celebrating OSCON’s 20th anniversary appeared first on Microsoft Open Source Blog.

This is the flow implemented in this post:

• DevOps commit code or configuration change
• VSTS Build builds and packages application
• VSTS Release invokes Packer to build a Linux image and store it in Managed Disks
• Packer invokes the Ansible Playbook provisioner to install JDK, Tomcat and SpringBoot application
• VSTS Release invokes Terraform to provision Infrastructure and uses Packer build image

Prerequisites:

• Configure custom VSTS agent with required tools as described in “How to create a custom VSTS agent on Azure ACI with Terraform“
• Service Principal with access to the Subscription
• Resource Group in which managed disks will be created
• Storage Account/Container to save Terraform state in (update "backend.tfvars" in the Terraform templates below with the storage account names).
  Terraform must store state about your managed infrastructure and configuration. This state is used by Terraform to map real world resources to your configuration, keep track of metadata, and to improve performance for large infrastructures.
• Ansible task extension installed from VSTS marketplace

Spring Boot Application Build

The application used for this example is the Java Spring Boot application from part 1 of this tutorial. First, we build and package the Spring Boot application using Gradle. You can import the full build definition from this GitHub repository or create a Java Gradle project from scratch by following the steps provided in this documentation: “Build your Java app with Gradle.” Here is outline of the steps and commands customizations:

1. Create a build definition (Build & Release tab > Builds).
2. Search and use "Gradle" definition.
   In the repository tab of build definition make sure the repository selected is the one where you pushed (Git).
3. In "Copy Files" – customize the step to copy all required scripts directories with templates to resulting artifact.
   ansible/**
   terraform/**
   packer/**

4. Add an additional "Copy Files" step, which will copy the Java WAR file to the resulting build artifact.

On the Triggers tab, enable continuous integration (CI). This tells the system to queue a build whenever new code is committed. Save and queue the build.

Infrastructure Provisioning

In this flow, Packer builds an Azure VM image and uses Ansible as the provisioner. Ansible Playbook installs the required software (Apache) and application on the server. The completed image is saved in Azure Managed disks. Terraform is used to build the infrastructure based on the Packer image.
Here is the Release pipeline definition, which can be imported from GitHub.

Deployment Flow

1. Start by defining Empty Release Definition, and link the build prepared above as an artifact.
2. Use custom VSTS Agent from "ACI-Pool"
3. Define Variable Group with environment variables that provide connectivity to subscription ARM_SUBSCRIPTION_ID, ARM_TENANT_ID. Service Principle ARM_CLIENT_ID, ARM_CLIENT_SECRET. And Storage account access key ARM_ACCESS_KEY.

And Variable ARM_RESOURCE_GROUP_DISKS that has the name of resource group to store the images.

4. Add these steps:
a. Packer build- invoke shell script to build image

Script executes the Packer template and sets the VSTS output variable "manageddiskname" to the disk created by Packer. This image will be used by Terraform to point VM ScaleSets to.

#!/bin/bash## execute packer build and send out to packer-build-output filepacker build -var playbook_drop_path=$6 ./app.json 2>&1 | tee packer-build-output.log## export output variable to VSTSexport manageddiskname=$(cat packer-build-output.log | grep ManagedImageName: | awk '{print $2}')echo "variable $manageddiskname"echo "##vso[task.setvariable variable=manageddiskname]$manageddiskname"

Packer template uses Azure builder to create image based on Red Hat and saves it in Managed Disk in the provided resource group (name includes timestamp for ease of identification).

{ "variables": { "tenant_id": "{{env `ARM_TENANT_ID`}}", "client_id": "{{env `ARM_CLIENT_ID`}}", "client_secret": "{{env `ARM_CLIENT_SECRET`}}", "managed_resource_group": "{{env `ARM_RESOURCE_GROUP_DISKS`}}", "subscription_id": "{{env `ARM_SUBSCRIPTION_ID`}}", "playbook_drop_path": "", "random_path": "{{timestamp}}" }, "builders": [{ "type": "azure-arm", "client_id": "{{user `client_id`}}", "client_secret": "{{user `client_secret`}}", "subscription_id": "{{user `subscription_id`}}", "tenant_id": "{{user `tenant_id`}}", "os_type": "Linux", "image_publisher": "RedHat", "image_offer": "RHEL", "image_sku": "7.3", "managed_image_resource_group_name": "{{user `managed_resource_group`}}", "managed_image_name": "demoPackerImage-{{isotime \"2006-01-02_03_04_05\"}}", "location": "Canada Central", "vm_size": "Basic_A1" }

To install the required components and application we are using Ansible Playbook. To invoke it, define a provisioner in the Packer template. First, we use shell provisioner to install Ansible, then "Ansible-local" to invoke the playbook on the image being created, and then shutdown the VM.

"provisioners": [ { "execute_command": "chmod +x {{ .Path }}; {{ .Vars }} sudo -E sh '{{ .Path }}'", "inline": [ "sudo yum install f ansible" ], "inline_shebang": "/bin/sh -x", "type": "shell" }, { "type": "ansible-local", "playbook_file": "{{user `playbook_drop_path`}}/ansible/site.yml", "playbook_dir": "{{user `playbook_drop_path`}}/ansible" }, { "execute_command": "chmod +x {{ .Path }}; {{ .Vars }} sudo -E sh '{{ .Path }}'", "inline": [ "/usr/sbin/waagent -force -deprovision+user && export HISTSIZE=0 && sync" ], "inline_shebang": "/bin/sh -x", "type": "shell" } ]}

Resulting image will have all the components installed using Ansible playbook. This solution does not require SSH to be enabled on the VM as it uses local provisioner.
Note: For Ansible to find all the roles and subdirectories "playbook_dir" should be specified. It will direct Ansible to copy all directory and subfolders to the staging directory, where Ansible provisioner is invoked in.
The Ansible Playbook used in the example (same as in Part 1) is running on localhost, installs JDK, Tomcat, and the Java Spring Boot application.

---- hosts: 127.0.0.1 become: true connection: local vars: http_port: 8080 https_port: 8443 admin_username: admin admin_password: adminsecret roles: - selinux - tomcat

Tomcat Role snippet installing the application:

- name: wait for tomcat to start wait_for: port={{http_port}}- name: unDeploy sample app file: path=/usr/share/tomcat/webapps/spring-music.war owner=tomcat group=tomcat state=absent- name: wait for tomcat to undeploy the app wait_for: path=/usr/share/tomcat/webapps/spring-music/ state=absent- name: Deploy sample app copy: src=web/build/libs/spring-music.war dest=/usr/share/tomcat/webapps/spring-music.war owner=tomcat group=tomcat notify: restart tomcat- name: Start Tomcat service: name=tomcat state=started enabled=yes

As a result, we can see the image build built, the Ansible Playbook run, and the managed disk name as an output of the task.

The newly created image could be verified in the resource group ("managed-disks" in our example).
Each image has timestamp as a suffix that helps to identify images for rollback and promotion (could use git hash or tag for traceability to source control).

Next step is provisioning infrastructure using Terraform:
b. Shell Script Terraform Init

Terraform must initialize Azure Resource provider and the configured backend for keeping the state (Azure storage in this example) before the use. Here is the snippet doing it from our Terraform template:

terraform { required_version = ">= 0.11" backend "azurerm" {}}# Configure the Microsoft Azure Providerprovider "azurerm" {}

Terraform initialization can be done by simply running "terraform init" command.
To avoid hard coding backend storage in the Terraform template, we are using a partial configuration and providing the required backend configuration in variables file – "backend.tfvars." Here a is configuration that uses a storage account we created as part of the prerequisites:

storage_account_name = "vstsbuildterraform"container_name = "terraform-state"key = "demo-packer.terraform.tfstate"

To initialize Terraform shell script will run init command with provided backend configuration:

#!/bin/bashterraform init -backend-config=backend.tfvars

Upon a successful run it will have following output indication that Terraform has been initialized.

c. Shell Script Terraform apply
Terraform apply will apply the changes required to reach the desired state of the configuration as defined by "main.tf."

Terraform generates an execution plan describing what it will do to reach the desired state, and then executes it to build the described infrastructure. As the configuration changes, Terraform is able to determine what changed and create incremental execution plans that can be applied.
In the example below, Terraform detected that some changes are required in the infrastructure.

The shell file executes the Terraform build and uses the build by Packer ManagedDisk name to locate the image used in the VM scale set.

terraform apply -auto-approve -var "manageddiskname=$6"

The full Terraform template can be found in GitHub.
It provisions the resource group, virtual network, subnet, public IP, load balancer and NAT rules, and VM scale set.
Here is the definition of VM scale set, pointing to the Packer image. Resources that are not created by Terraform are referred to as "data" definition as opposed to "resource."

# Points to Packer build imagedata "azurerm_image" "image" { name = "${var.manageddiskname}" resource_group_name = "managed-images"}# Create virtual machine sclae setresource "azurerm_virtual_machine_scale_set" "vmss" { name = "vmscaleset" location = "${azurerm_resource_group.demo_resource_group.location}" resource_group_name = "${azurerm_resource_group.demo_resource_group.name}" upgrade_policy_mode = "Automatic" sku { name = "Standard_DS1_v2" tier = "Standard" capacity = 2 } storage_profile_image_reference { id = "${data.azurerm_image.image.id}" } storage_profile_os_disk { name = "" caching = "ReadWrite" create_option = "FromImage" managed_disk_type = "Premium_LRS" } os_profile { computer_name_prefix = "myvm" admin_username = "azureuser" admin_password = "xxxx" } os_profile_linux_config { disable_password_authentication = true ssh_keys { path = "/home/azureuser/.ssh/authorized_keys" key_data = "ssh-rsa xxxx" } } network_profile { name = "terraformnetworkprofile" primary = true ip_configuration { name = "IPConfiguration" subnet_id = "${azurerm_subnet.demo_subnet.id}" load_balancer_backend_address_pool_ids = ["${azurerm_lb_backend_address_pool.bpepool.id}"] } } tags { environment = "Terraform Demo" }}

Provisioned infrastructure will look like this:

As a result of the build, we have a Spring Boot application up and running on an Azure VM scale set and it could be scaled up and down quickly, according to demand.

Conclusion

In this example, we demonstrated a simple flow that provides application deployment and infrastructure automation, and builds the immutable image that can be promoted between environments. The build history is stored in the Azure resource group and each image is tagged, and could be rolled back very easily by pointing the VM scale set to a previous version. In the next article we will demonstrate more complex flow, incorporating planning, approving, verifying policies, and testing infrastructure.
Note: There is a "Packer" task available on VSTS marketplace, Currently it does not support managed disks, enhancement is coming and we will be able to replace the shell script.

The post Tutorial: Immutable infrastructure for Azure, using VSTS, Terraform, Packer and Ansible appeared first on Microsoft Open Source Blog.