OTN TechBlog

Subscribe to OTN TechBlog feed
Oracle Blogs
Updated: 3 weeks 3 days ago

Podcast: Inspiring Innovation and Entrepreneurism in Young People

Wed, 2018-12-05 07:37

A common thread connecting the small army of IT professionals I've met over the last 20 years is that their interest in technology developed when they were very young, and that youthful interest grew into a full-fledged career. That's truly wonderful. But what happens if a young person never has a chance to develop that interest? And what can be done to draw those young people to careers in technology? In this Oracle Groundbreakers Podcast extra you will meet someone who is dedicated to solving that very problem.

Karla Readshaw is director of development for Iridescent, a non-profit organization focused on bringing quality STEM education (science, technology, engineering, and mathematics) to young people -- particularly girls -- around the globe.

"Our end goal is to ensure that every child, with a specific focus on underrepresented groups -- women and minorities -- has the opportunity to learn, and develop curiosity, creativity and perseverance, what real leaders are made of," Karla explains in her presentation.

Iridescent, through its Technovation program, provides middle- and high-school girls with the resources to develop solutions to real problems in their local communities, "leveraging technology and engineering for social good," as Karla explains.

Over a three-month period, the girls involved in the Technovation program identify a problem within their community, design and develop a mobile app to address the issue, and then build a business around that app, all under the guidance of an industry mentor.

The results are impressive. In one example, a team of hearing-impaired girls in Brazil developed an app that teaches American Sign Language, and then developed a business around it. In another example, a group of high-school girls in Guadalajara, Mexico drew on personal experience to develop an app that strengthens the relationship between Alzheimers patients and their caregivers. And a group of San Francisco Bay area girls created a mobile app that will help those with autism to improve social skills and reduce anxiety.

Want to learn more about the Technovation program, and about how you can get involved? Just listen to this podcast. 

This program was recorded during Karla's presentation at the Women In Technology Breakfast held on October 22, 2018 as part of Oracle Code One.

Additional Resources Coming Soon
  • Baruch Sadogursky, Leonid Igolnik, and Viktor Gamov discuss DevOps, streaming, liquid software, and observability in this podcast captured during Oracle Code One 2018.
  • GraphQL and REST: An Objective Comparison: a panel of experts weighs the pros and cons of each of these approaches in working with APIs. 
  • Database: Breaking the Golden Rules: There comes a time question, and even break,  long-established rules. This program presents a discussion of the database rules that may no longer be advantageous. 
Subscribe

Never miss an episode! The Oracle Groundbreakers Podcast is available via:

Deploy containers on Oracle Container Engine for Kubernetes using Developer Cloud

Tue, 2018-12-04 08:25

In my previous blog, I described how to use Oracle Developer Cloud to build and push the Node.js microservice Docker image on DockerHub. This blog will help you understand, how to use Oracle Developer Cloud to deploy the Docker image pushed to DockerHub on Container Engine for Kubernetes.

Container Engine for Kubernetes

Container Engine for Kubernetes is a developer-friendly, container-native, enterprise-ready managed Kubernetes service for running highly available clusters with the control, security, and predictable performance of Oracle Cloud Infrastructure. Visit the following link to learn about Oracle’s Container Engine for Kubernetes:

https://cloud.oracle.com/containers/kubernetes-engine

Prerequisites for Kubernetes Deployment

  1. Access to an Oracle Cloud Infrastructure (OCI) account
  2. A Kubernetes cluster set up on OCI
    This tutorial explains how to set up a Kubernetes cluster on OCI. 

Set Up the Environment:

Create and Configure Build VM Templates and Build VMs

You’ll need to create and configure the Build VM template and Build VM with the required software, which will be used to execute the build job.

 

Click the user avatar, then select Organization from the menu. 

 

Click VM Templates then New Template. In the dialog that pops up, enter a template name, such as Kubernetes Template, select “Oracle Linux 7” for the platform, then click the Create button.  

 

After the template has been created, click Configure Software.

 

Select Kubectl and OCIcli (you’ll be asked to add Python3 3.6, as well) from the list of software bundles available for configuration, then click + to add these software bundles to the template. 

Click the Done button to complete the software configuration for that Build VM template.

           

From the Virtual Machines page, click +New VM and, in the dialog that pops up, enter the number of VMs you want to create and select the VM Template you just created (Kubernetes Template).

 

Click the Add button to add the VM.

 

Kubernetes deployment scripts

From the Project page, click the + New Repository button to add a new repository.

 

After creating the repository, Developer Cloud will bring you to the Code page, with the  NodejsKubernetes repository showing. Click the +File button to create a new file in the repository. (The README file in the repository was created when the project was created.) 

 

Copy the following script into a text editor and save the file as nodejs_micro.yaml.

apiVersion: apps/v1beta1 kind: Deployment metadata: name: nodejsmicro-k8s-deployment spec: selector: matchLabels: app: nodejsmicro replicas: 1 # deployment runs 1 pods matching the template template: # create pods using pod definition in this template metadata: labels: app: nodejsmicro spec: containers: - name: nodejsmicro image: abhinavshroff/nodejsmicro4kube:latest ports: - containerPort: 80 #Endpoint is at port 80 in the container --- apiVersion: v1 kind: Service metadata: name: nodejsmicro-k8s-service spec: type: NodePort #Exposes the service as a node port ports: - port: 80 protocol: TCP targetPort: 80 selector: app: nodejsmicro

 

Click the Commit button to create the file and commit the code changes.

 

Click the Commit button in the Commit changes dialog that displays.

You should see the nodejs_micro.yaml file in the list of files for the NodejsKubernetes.git repository, as shown in the screenshot below.

 

Configuring the Build Job

Click Build on the navigation bar to display the Build page. Click the +New Job button to create a new build job. In the New Job dialog box, enter NodejsKubernetesDeploymentBuild for the Job name and, from the Software Template drop-down list, select Kubernetes Template as the Software Template. Then click the Create Job button to create the build job.

 

After the build job has been created, you’ll be brought to the configure screen. Click the Source Control tab and select NodejsKubernetes.git from the repository drop-down list. This is the same repository where you created the nodejs_micro.yaml file. Select master from the Branch drop-down list.

 

In the Builders tab, click the Add Builder drop-down and select OCIcli Builder from the drop-down list. 

To see what you need to fill in for each of the input fields in the OCIcli Builder form and to find out where to retrieve these values, you can either read my “Oracle Cloud Infrastructure CLI on Developer Cloud” blog or the documentation link to the “Access Oracle Cloud Infrastructure Services Using OCIcli” section in Using Oracle Developer Cloud Service.

Note: The values in the screenshot below have been obfuscated for security reasons. 

 

Click the Add Builder drop-down list again and select Unix Shell Builder.

 

In the text area of the Unix Shell Builder, add the following script that downloads the Kubernetes config file and deploys the container on Oracle Kubernetes Engine, which you created by following the instructions in my previous blog. Click the Save button to save the build job. 

 

mkdir -p $HOME/.kube oci ce cluster create-kubeconfig --cluster-id ocid1.cluster.oc1.iad.aaaaaaaaafrgkzrwhtimldhaytgnjqhazdgmbuhc2gemrvmq2w --file $HOME/.kube/config --region us-ashburn-1 export KUBECONFIG=$HOME/.kube/config kubectl config view kubectl get nodes kubectl create -f nodejs_micro.yaml sleep 120 kubectl get services nodejsmicro-k8s-service kubectl get pods kubectl describe pods

This script creates the kube directory, uses the OCIcli command oci ce cluster to download the Kubernetes cluster config file, then sets the KUBECONFIG environment variable.

The kubectl config and get nodes commands just let you view the cluster configuration and see the node details of the cluster. The create command actually deploys the Docker container on the Kubernetes cluster. We run the get services and, get pods commands to retrieve the IP address and the port of the deployed container. Note that the nodejsmicro-k8s-service name was previously configured in the nodejs_micro.yaml file.

Note: The OCID for the cluster, mentioned in the script above, needs to be replaced by the one which you have. 

 

Click the Build Now button to start executing the Kubernetes deployment build. You can click the Build Log icon to view the build execution logs.

 

After the build job executes successfully, you can examine the build log to retrieve the IP address and the port for the deployed service on Kubernetes cluster. You’ll need to look for the IP address and the port under the deployment name you configured in the YAML file.

 

Use the IP address and the port that you retrieved in the format shown below and see the output in your browser.

http://<IP Address>:port/message

Note: The message output you see may differ from what is shown here, based on what you coded in the Node.js REST application that was containerized.

 

So, now you’ve seen how Oracle Developer Cloud streamlines and simplifies the process for managing the automation for building and deploying Docker containers on Oracle Kubernetes Engine.

Happy Coding!

 

**The views expressed in this post are my own and do not necessarily reflect the views of Oracle

Finding Symmetry

Mon, 2018-11-26 18:30

(Originally published on Medium)

Evolving the design of Eclipse Collections through symmetry.

Got Eclipse Collections stickers?

Find the Missing Types

New Eclipse Collections types on the left add to the existing JDK types on the right

Eclipse Collections has a bunch of new types you will not find in the JDK. These types give developers useful functionality that they need. There is an extra cost to supporting additional container types, especially when you factor in having support for primitive types across these types.

These missing types are important. They help Eclipse Collections return better return types for iteration patterns.

Type Symmetry

Eclipse Collections has pretty good symmetry between object and primitive types.


The missing container types are fixed sized primitive arrays, primitive BiMaps, primitive Multimaps, and some of the primitive Intervals (only IntInterval exists today). String really only should exist as a primitive immutable collection of either char or int. Eclipse Collections has ,CharAdapter, CodePointAdapter and CodePointList which provide a rich set of iteration protocols that work with Strings.

API Symmetry

There is still much that can be done to improve the symmetry between the object and primitive APIs. There are some APIs that cannot be replicated without adding new types. For instance, it would be less than desirable to implement a primitive version of groupBy with the current Multimap implementations because the only option would be to box the primitive Lists, Sets or Bags. Since there are a large number of APIs in Eclipse Collections, I will only draw attention to some of the major APIs that do not currently have symmetry between object and primitive collections. The following methods are missing on the primitive iterables.

  1. groupBy / groupByEach
  2. countBy / countByEach
  3. aggregateBy / aggregateInPlaceBy
  4. partition
  5. reduce / reduceInPlace
  6. toMap
  7. All “With” methods

Of all the missing APIs on primitive collections perhaps the most subtle and yet glaring difference is the lack of “With” methods. It is not clear if the “With” methods would be as useful for primitive collections as they are with object collections. For some usage examples of the “With” methods on the object collection APIs, read my blog titled “Preposition Preference”. The “With” methods allow for more APIs to be used with Method References.

This is what the signatures for some of the “With” methods might look like on IntList.

<P> boolean anySatisfyWith(IntObjectPredicate<? super P> predicate, P parameter); <P> boolean allSatisfyWith(IntObjectPredicate<? super P> predicate, P parameter); <P> boolean noneSatisfyWith(IntObjectPredicate<? super P> predicate, P parameter); <P> IntList selectWith(IntObjectPredicate<? super P> predicate, P parameter); <P> IntList rejectWith(IntObjectPredicate<? super P> predicate, P parameter); Default Methods to the Rescue

The addition of default methods in Java 8 has been of tremendous help increasing the symmetry between our object and primitive APIs. In Eclipse Collections 10.x we will be able to leverage default methods even more, as we now have the ability to use container factory classes in interfaces. The following examples show how the default implementations of countBy and countByWith has been optimized using the Bags factory.

default <V> Bag<V> countBy(Function<? super T, ? extends V> function) { return this.countBy(function, Bags.mutable.empty()); } default <V, P> Bag<V> countByWith(Function2<? super T, ? super P, ? extends V> function, P parameter) { return this.countByWith(function, parameter, Bags.mutable.empty()); } More on Eclipse Collections API design

To find out more about the design of the Eclipse Collections API, check out this slide deck and the following presentation.


You can also find a set of visualizations of the Eclipse Collection library in this blog post.

Eclipse Collections is open for contributions. If you like the library, you can let us know by starring it on GitHub.

Install Spinnaker with Halyard on Kubernetes

Sun, 2018-11-25 18:30

(Originally published on Medium)

This article will walk you through the steps that can be used to install and setup a Spinnaker instance on Kubernetes that’s behind a corporate proxy. We will use Halyard on docker to manage our Spinnaker deployment.

For a super quick installation, you can use Spinnaker’s Helm chart

Prerequisites

Make sure to take care of these prerequisites before installing Spinnaker:

  • Docker 17.x with proxies configured (click here for OL setup)
  • A Kubernetes cluster (click here for OL setup)
  • Helm with RBAC enabled (click here for generic setup)
Install Halyard on Docker

Halyard is used to install and manage a Spinnaker deployment. In fact, all production grade Spinnaker deployments require Halyard in order to properly configure and maintain Spinnaker. Let’s use Docker to install Halyard.

Create a docker volume or create a host directory to hold the persistent data used by Halyard. For the purposes of this article, let’s create a host directory and grant users full access:

mkdir halyard && chmod 747 halyard

Halyard needs to interact with your Kubernetes cluster. So we pass the $KUBECONFIG file to it. One way would be to mount a host directory into the container that has your Kubernetes cluster details. Let’s create the directory “k8s” and copy the $KUBECONFIG file and make it visible to the user inside the Halyard container.

mkdir k8s && cp $KUBECONFIG k8s/config && chmod 755 k8s/config

Time to download and run Halyard docker image:

docker run -p 8084:8084 -p 9000:9000 \ --name halyard -d \ -v /sandbox/halyard:/home/spinnaker/.hal \ -v /sandbox/k8s:/home/spinnaker/k8s \ -e http_proxy=http://<proxy_host>:<proxy_port> \ -e https_proxy=https://<proxy_host>:<proxy_port> \ -e JAVA_OPTS="-Dhttps.proxyHost=<proxy_host> -Dhttps.proxyPort=<proxy_port>" \ -e KUBECONFIG=/home/spinnaker/k8s/config \ gcr.io/spinnaker-marketplace/halyard:stable

Make sure to replace the “<proxy_host>” and “<proxy_port>” with your corporate proxy values.

Login to the “halyard” container to test the connection to your Kubernetes cluster:

docker exec -it halyard bash kubectl get pods -n spinnaker

Optionally, if you want command completion run the following inside the halyard container:

source <(hal --print-bash-completion) Set provider to “Kubernetes”

In Spinnaker terms, to deploy applications we use integrations to specific cloud platforms. We have to configure Halyard and set the cloud provider to Kubernetes v2 (manifest based) since we want to deploy Spinnaker onto a Kubernetes cluster:

hal config provider kubernetes enable

Next we create an account. In Spinnaker, an account is a named credential Spinnaker uses to authenticate against an integration provider — Kubernetes in our case:

hal config provider kubernetes account add <my_account> \ --provider-version v2 \ --context $(kubectl config current-context)

Make sure to replace “<my_account>” with an account name of your choice. Save the account name in an environment variable $ACCOUNT. Next, we need to enable Halyard to use artifacts:

hal config features edit --artifacts true Set deployment type to “distributed”

Halyard supports multiple types of Spinnaker deployments. Let’s tell Halyard that we need a distributed deployment of Spinnaker:

hal config deploy edit --type distributed --account-name $ACCOUNT Set persistent store to “Minio”

Spinnaker needs a persistent store to save the continuous delivery pipelines and other configurations. Halyard let’s you choose from multiple storage providers. For the purposes of this article, we will use “Minio”.

Let’s use Helm to install a simple instance of Minio. Run the command from outside the Halyard docker container on a node that has access to your Kubernetes cluster and Helm:

helm install --namespace spinnaker --name minio --set accessKey= <access_key> --set secretKey=<secret_key> stable/minio

Make sure to replace “<access_key>” and “<secret_key>” with values of your choosing.

If you are using a local k8s cluster with no real persistent volume support, you can pass “persistence.enabled=false” as a set to the previous Helm command. As the flag suggests, if Minio goes down, you will lose your changes.

According to the Spinnaker docs, Minio does not support versioning objects. So let’s disable versioning under Halyard configuration. Back in the Halyard docker container run these commands:

mkdir ~/.hal/default/profiles && \ touch ~/.hal/default/profiles/front50-local.yml

Add the following to the front50-local.yml file:

spinnaker.s3.versioning: false

Now run the following command to configure the storage provider:

echo $MINIO_SECRET_KEY | \ hal config storage s3 edit --endpoint http://minio:9000 \ --access-key-id $MINIO_ACCESS_KEY \ --secret-access-key

Make sure to set the $MINIO_ACCESS_KEY and $MINIO_SECRET_KEY environment variables to the <access_key> and <secret_key> values that you used when you installed Minio.

Finally, let’s enable the s3 storage provider:

hal config storage edit --type s3 Set version to “latest”

You have to select a specific version of Spinnaker and configure Halyard so it knows which version to deploy. You can view the available versions by running this command:

hal version list

Pick the latest version number from the list (or any other version that you want to deploy) and update Halyard:

hal config version edit --version <version> Deploy Spinnaker

At this point, Halyard should have all the information that it needs to deploy a Spinnaker instance. Let’s go ahead and deploy Spinnaker by running this command:

hal deploy apply

Note that first time deployments might take a while.

Make Spinnaker reachable

We need to expose the Spinnaker UI and Gateway services in order to interact with the Spinnaker dashboard and start creating pipelines. When we deployed Spinnaker using Halyard, a number of Kubernetes services get created in the “spinnaker” namespace. These services are by default exposed within the cluster (type is “ClusterIP”). Let’s change the service type of the services fronting the UI and API servers of Spinnaker to “NodePort” to make them available to end users outside the Kubernetes cluster.

Edit the “spin-deck” service by running the following command:

kubectl edit svc spin-deck -n spinnaker

Change the type to “NodePort” and optionally specify the port on which you want the service exposed. Here’s a snapshot of the service definition:

... spec: type: NodePort ports: - port: 9000 protocol: TCP targetPort: 9000 nodePort: 30900 selector: app: spin cluster: spin-deck sessionAffinity: None status: ...

Next, edit the “spin-gate” service by running the following command:

kubectl edit svc spin-gate -n spinnaker

Change the type to “NodePort” and optionally specify the port on which you want the API gateway service exposed.

Note that Kubernetes services can be exposed in multiple ways. If you want to expose Spinnaker onto the public internet, you can use a LoadBalancer or an Ingress with https turned on. You should configure authentication to lock down access to unauthorized users.

Save the node’s hostname or its IP address that will be used to access Spinnaker in an environment variable $SPIN_HOST. Using Halyard, configure the UI and API servers to receive incoming requests:

hal config security ui edit \ --override-base-url "http://$SPIN_HOST:30900" hal config security api edit \ --override-base-url "http://$SPIN_HOST:30808"

Redeploy Spinnaker so it picks up the configuration changes:

hal deploy apply

You can access the Spinnaker UI at “http://$SPIN_HOST:30900”

Create a “hello-world” application

Let’s take Spinnaker for a spin (pun intended). Using Spinnaker’s UI, let’s create a “hello-world” application. Use the “Actions” drop-down and click “Create Application”:


Once the application is created, navigate to “Pipelines” tab and click “Configure a new pipeline”:


Now add a new stage to the pipeline to create a manifest based deployment:


Under the “Manifest Configuration”, add the following as the manifest source text:

apiVersion: apps/v1 kind: Deployment metadata: labels: app: hello-world name: hello-world spec: replicas: 1 selector: matchLabels: app: hello-world template: metadata: labels: app: hello-world spec: containers: - image: '<docker_repository>:5000/helloworld:v1' name: hello-world ports: - containerPort: 80

Replace the “<docker_repository>” with the name of your internal docker registry that is made available to your Kubernetes cluster.

Let’s take a quick side tour to create a “helloworld” docker image. We will create a “nginx” based image that hosts an “index.html” file containing:

<h1>Hello World</h1>

We will then create the corresponding “Dockerfile” in the same directory that holds the “index.html” file from the previous step:

FROM nginx:alpine COPY . /usr/share/nginx/html

Next, we build the docker image by running the following command:

docker build -t <docker_repository>:5000/helloworld:v1 .

Make sure to replace the “<docker_repository>” with the name of your internal docker registry that is made available to your Kubernetes cluster. Push the docker image to the “<docker_repository>” to make it available to the Kubernetes cluster.

docker push <docker_repository>:5000/helloworld:v1

Back in the Spinnaker UI, let’s manually run the “hello-world” pipeline. After a successful execution you can drill down into the pipeline instance details:


To quickly test our hello-world app, we can create a manifest based “LoadBalancer” in the Spinnaker UI. Click the “+” icon:


Add the following service definition to create the load balancer:

kind: Service apiVersion: v1 metadata: name: hello-world spec: type: NodePort selector: app: hello-world ports: - protocol: TCP port: 80 targetPort: 80 nodePort: 31080

Once Spinnaker provisions the load balancer, hit the hello-world app’s URL at “http://$SPIN_HOST:31080” in your browser. Voila! There you have it, “Hello World” is rendered.

Conclusion

Spinnaker is a multi-cloud continuous delivery platform for releasing software with high velocity. We used Halyard to install Spinnaker on a Kubernetes cluster and deployed a simple hello-world pipeline. Of course, we barely scratched the surface in terms of what Spinnaker offers. Head over to the guides to learn more about Spinnaker.

.cb11v2-cover {display : none !important;}

How to Connect a Go Program to Oracle Database using goracle

Wed, 2018-11-21 18:10

Given that we just released Go programming language RPMs on Oracle Linux yum server, I figured it would be a good opportunity to take the goracle driver for a spin on Oracle Linux and connect a Go program to Oracle Database. goracle implements a Go database/sql driver for Oracle Database using ODPI-C (Oracle Database Programming Interface for C)

1. Update Yum Configuration

First, make sure you have the most recent Oracle Linux yum server repo file by grabbing it from the source:

$ sudo mv /etc/yum.repos.d/public-yum-ol7.repo /etc/yum.repos.d/public-yum-ol7.repo.bak $ sudo wget -O /etc/yum.repos.d/public-yum-ol7.repo http://yum.oracle.com/public-yum-ol7.repo 2. Enable Required Repositories to install Go and Oracle Instant Client $ sudo yum -y install yum-utils $ sudo yum-config-manager --enable ol7_developer_golang111 ol7_oracle_instantclient 3. Install Go and Verify

Note that you must install git also so that go get can fetch and build the goracle module.

$ sudo yum -y install git golang $ go env GOARCH="amd64" GOBIN="" GOCACHE="/home/vagrant/.cache/go-build" GOEXE="" GOFLAGS="" GOHOSTARCH="amd64" GOHOSTOS="linux" GOOS="linux" GOPATH="/home/vagrant/go" GOPROXY="" GORACE="" GOROOT="/usr/lib/golang" GOTMPDIR="" GOTOOLDIR="/usr/lib/golang/pkg/tool/linux_amd64" GCCGO="gccgo" CC="gcc" CXX="g++" CGO_ENABLED="1" GOMOD="" CGO_CFLAGS="-g -O2" CGO_CPPFLAGS="" CGO_CXXFLAGS="-g -O2" CGO_FFLAGS="-g -O2" CGO_LDFLAGS="-g -O2" PKG_CONFIG="pkg-config" GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build013415374=/tmp/go-build -gno-record-gcc-switches" $ go version go version go1.11.1 linux/amd64 4. Install Oracle Instant Client and Add its Libraries to the Runtime Link Path

Oracle Instant Client is available directly from Oracle Linux yum server. If you are deploying applications using Docker, I encourage you to check out our Oracle Instant Client Docker Image.

sudo yum -y install oracle-instantclient18.3-basic

Before you can make use of Oracle Instant Client, set the runtime link path so that goracle can find the libraries it needs to connect to Oracle Database.

sudo sh -c "echo /usr/lib/oracle/18.3/client64/lib > /etc/ld.so.conf.d/oracle-instantclient.conf" sudo ldconfig

5. Install the goracle Driver

Following the instructions from the goracle repo on GitHub:

$ go get gopkg.in/goracle.v2 6. Create a Go Program to Test your Connection

Create a file db.go as follows. Make sure you change your connect string.

package main import ( "fmt" "database/sql" _ "gopkg.in/goracle.v2" ) func main(){ db, err := sql.Open("goracle", "scott/tiger@10.0.1.127:1521/orclpdb1") if err != nil { fmt.Println(err) return } defer db.Close() rows,err := db.Query("select sysdate from dual") if err != nil { fmt.Println("Error running query") fmt.Println(err) return } defer rows.Close() var thedate string for rows.Next() { rows.Scan(&thedate) } fmt.Printf("The date is: %s\n", thedate) } 7. Run it!

Time to test your program.

$ go run db.go The date is: 2018-11-21T23:53:31Z Conclusion

In this blog post, I showed how you can install the Go programming language and Oracle Instant Client from Oracle Linux yum server and use it together with the goracle Driver to connect a Go program to Oracle Database.

References

Podcast: Hadoop, JRuby, Grails, and Python Creators Talk Tech Trends

Tue, 2018-11-20 23:00

The first thing you may notice when listening to this program is that the podcast has undergone another name change. What was once the Oracle Developer Community Podcast is now the Oracle Groundbreakers Podcast. A little change is good now and then, and this is exactly that, a little change.

And it is by no coincidence that change is the core theme of this program, how various trends and technologies have shaped the IT landscape over the past year, and how other trends will shape the future.

Recorded live on Tuesday October 23, 2018 during Oracle Code One, this very special program features Doug Cutting, founder of the Apache Lucene, Nutch, Hadoop and Avro open source projects; Charles Nutter, co-leader of JRuby; Graeme Rocher, Grails Open Source project lead; Guido van Rossum, creator of the Python language; and Siddartha Agarwal, group vice president of product management and strategy for the Oracle Cloud Platform.

As befitting their varied specialties and interests, each of the panelists offers a unique perspective on the swirl of technologies that have changed, and will continue to change, the software development landscape.

During one segment I asked the panelists to talk about the trends or technologies that have had the greatest impact on them as individuals and on the work they do. 

Graeme Rocher cites GraalVM as having had "a massive impact" on how he thinks about the way in which modern frameworks and Java tools are built.  "If you want to support Graal VM’s capability to compile down to native images, which, again, further allows you to optimize startup time and reduce memory consumption, you really have to plan ahead in terms of how you can make that happen. It's not something you can just add on after the fact. So supporting Graal’s native image has changed my workflow," he admits. "Now I'm considering, should implement this feature? Will it work on Graal? And it's it's having a massive impact on planning in terms of the next 18 months." 

By his own admission, Guido van Rossum lives in a different environment. "My workflow has very little to do with what Java developers typically encounter." In his world, social media has had the greatest impact. "It has spilled over from being social to affecting my work, affecting the Python community. The state of how people are trying to influence developments through social media has really changed recently." 

Charles Nutter spends his time in the tech trenches. "I work pretty low-level. On JRuby I mostly do optimization compiler work, sitting and staring at assembly dumps all day. In the past year his work was most affected by the new LLVM-based JIT compiler in Azul’s Zing, and by OpenJ9 and the availability of the J9 source code. "And then, of course, the Graal JIT, which is separate from the Graal VM project, is actually available as an experimental JIT in Java 11," Charles explains. "You can just flip it on and get the benefit of a whole bunch of new optimizations. It actually helps JRuby quite a bit. So it kind of seemed like we'd gotten to a point where the JVM JITs had gotten as good as they were going to get, and then everything changes again. So it's an exciting time for me on the JRuby project."

In contrast to Charles Nutter, Doug Cutting tends to be more very high level. "I'm talking to people more about the data systems they're building" he says. According to Doug, the technologies that get people excited don't necessarily reflect what they are actually doing. People may be talking about machine learning or artificial intelligence, but that talk doesn't necessarily indicate action. "They’re not even moving to the cloud and in a big way." But Doug sees people are starting to use  and get value from "next-generation data platforms that have been around now for a decade." 

"We really do see people ingesting large amounts of what they call unstructured data, and exploring it using a suite of open-source tools," Doug explains. "That was the hot technology five years ago, and now it's becoming mainstream and beginning to have a large impact in a lot of conservative industries," such as banking, telco, automotive, and healthcare. "That's exciting." 

The excitement and energy extends into Siddartha Agarwal's world as well. "There are two or three things that we've had to focus on quite a bit," he admits.  "We've been focused a lot on delivering a managed Kubernetes service and then delivering a functions platform delivered as a service that is not locked into a particular cloud," he explains.  "We've launched that as an open source project called Fn Project.

APIs have also occupied Siddartha's focus. "APIs are absolutely critical. Everyone's using APIs for everything. So how can you enable them to run the security of the API anywhere?" What about rate limiting policies? What about security authentication? "You need a gateway," says Siddartha. "That gateway must be able to in our public cloud or in on-prem data centers, because you might not have APIs going to the cloud or consumption in the cloud, or running in third-party data centers. So it’s the notion of hybrid, in that it’s more about multi-cloud and across on-prem in public cloud."

Elsewhere in the program the panelists share their insight on the general impact on the industry of the key trends and technologies, and on the adjustments developers will have to make on the future. You'll want to hear the entire conversation. 

Listen!. 

The Panelists Doug Cutting Doug Cutting
Chief Architect, Cloudera
Founder, Apache Lucene, Nutch, Hadoop and Avro open source projects
Twitter  LinkedIn 
  Charles Nutter Charles Nutter
Senior Principal Software Engineer, Red Hat
Co-Lead, JRuby
Twitter LinkedIn   

 

Graeme Rocher Graeme Rocher
Grails Project Lead, OCI
Project Lead, Grails Open Source Project
Twitter LinkedIn  
  Guido van Rossum Guido van Rossum
Principal Engineer, Dropbox
Creator, Python Language
Twitter LinkedIn  

 

Siddartha Agarwal Siddartha Agarwal
Group Vice President, Product Management and Strategy, Oracle Cloud Platform
Twitter LinkedIn  
  Additional Resources Coming Soon
  • Karla Readshaw, director of development at Iridescent,  talks about the Technovation program  which "invites teams of girls from all over the world to learn and apply the skills needed to solve real-world problems through technology" in this podcast extra recorded during her presentation at the Women in Techology Breakfast at Oracle Code One 2018. 
  • Baruch Sadogursky, Leonid Igolnik, and Viktor Gamov discuss DevOps, streaming, liquid software, and observability in this podcast captured during Oracle Code One 2018.
  • GraphQL vs REST: a panel of experts weighs the pros and cons of each of these approaches in working with APIs. 
Subscribe

Never miss an episode! The Oracle Developer Community Podcast is available via:

From locally running Node application to Cloud based Kubernetes Deployment

Thu, 2018-11-15 18:30

(Originally published at technology.amis.nl)

In this article I will discuss the steps I had to go through in order to take my locally running Node application — with various hard coded and sometimes secret values — and deploy it on a cloud based Kubernetes cluster. I will discuss the containerization of the application, the replacement of hard coded values with references to environment variables, the Docker container image manipulation, the creation of the Kubernetes yaml files for creating the Kubernetes resources and finally the actual execution of the application.

Background

A few days ago in Tokyo I presented at the local J-JUG event as part of the Oracle Groundbreakers Tour of Asia and Pacific. I had prepared a very nice demo: an update in a cloud based Oracle Database was replicated to another cloud based database — a MongoDB database. In this demo, I first used Twitter as the medium for exchanging the update event and then the Oracle Event Hub (managed Apache Kafka) cloud service.

This picture visualizes what I was trying to do:


However, my demo failed. I ran a local Node (JS) application that would be invoked over HTTP from within the Oracle Database — and that would publish to Twitter and Kafka. When I was working on the demo in my hotel room, it was all working just fine. I used ngrok to expose my locally running application on the public internet — a great way to easily integrate local services in cloud-spanning demonstrations. It turned out that use of ngrok was not allowed by the network configuration at the Oracle Japan office where I did my presentation. There was no way I could get my laptop to create the tunnel to the ngrok service that would allow it to hand over the HTTP request from the Oracle Database.

This teaches me a lesson. No matter how convenient it may be to run stuff locally — I really should be able to have all components of this demo running in the cloud. And the most obvious way — apart from using a Serverless Function — is to deploy that application on a Kubernetes cluster. Even though I know how to get there — I realized the steps are not as engrained in my head and fingers as should be the case — especially in order to restore my demo to its former glory in less than 30 minutes.

The Action Plan

My demo application — somewhat quickly put together — contains quite a few hard coded values, including confidential settings such as Kafka Server IP address and Topic name as well as Twitter App Credentials. The first step I need to take is to remove all these hard coded values from the application code and replace them with references to environment variables.

The second big step is to build a container for and from my application. This container needs to provide the Node runtime, have all npm modules used by the application and contain the application code itself. The container should automatically start the application and expose the proper port. At the end of this step, I should be able locally run my application in a Docker container — injecting values for the environment variables with the Docker run command.

The third step is the creation of a Container Image from the container — and pushing that image (after meaningful tagging) to a container registry.

Next is the preparation of the Kubernetes resources. My application consists of a Pod and a Service (in Kubernetes terms) that are combined in a Deployment in its own Namespace. The Deployment makes use of two Secrets — one contains the confidential values for the Kafka Server (IP address and topic name) and the other the Twitter client app credentials. Values from these Secrets are used to set some of the environment variables. Other values are hard coded in the Deployment definition.

After arranging access to a Kubernetes Cluster instance — running in the Oracle Cloud Infrastructure, offered through the Oracle Kubernetes Engine (OKE) service — I can deploy the K8S resources and make the application running. Now, finally, I can point my Oracle Database trigger to the service endpoint on Kubernetes in the cloud and start publishing tweets for all relevant database updates.

At this point, I should — and you likewise after reading the remainder of this article — have a good understanding for how to Kubernetalize a Node application, so that I will never be stymied in my demos by stupid network problems. I want to not even think twice about taking my local application and turn it into a containerized application that is running on Kubernetes.

Note: the sources discussed in this article can be found on GitHub: https://github.com/lucasjellema/groundbreaker-japac-tour-cqrs-via-twitter-and-event-hub/tree/master/db-synch-orcl-2-mongodb-over-twitter-or-kafka.

1. Replace Hard Coded Values with Environment Variable References

My application contained the hard coded values of the Kafka Broker endpoint and my Twitter App credentials secrets. For a locally running application that is barely acceptable. For an application that is deployed in a cloud environment (and whose source are published on GitHub) that is clearly not a good idea.

Any hard coded value is to be removed from the code — replaced with a reference to a an environment variable, using the Node expression:

process.env.NAME_OF_VARIABLE

or

process.env[‘NAME_OF_VARIABLE’]

Let’s for now not worry how these values are set and provided to the Node application.

I have created a generic code snippet that will check upon starting the application if all expected Environment Variables have been defined and if not writes a warning to the output:

const REQUIRED_ENVIRONMENT_SETTINGS = [ {name:"PUBLISH_TO_KAFKA_YN" , message:"with either Y (publish event to Kafka) or N (publish to Twitter instead)"}, {name:"KAFKA_SERVER" , message:"with the IP address of the Kafka Server to which the application should publish"}, {name:"KAFKA_TOPIC" , message:"with the name of the Kafka Topic to which the application should publish"}, {name:"TWITTER_CONSUMER_KEY" , message:"with the consumer key for a set of Twitter client credentials"}, {name:"TWITTER_CONSUMER_SECRET" , message:"with the consumer secret for a set of Twitter client credentials"}, {name:"TWITTER_ACCESS_TOKEN_KEY" , message:"with the access token key for a set of Twitter client credentials"}, {name:"TWITTER_ACCESS_TOKEN_SECRET" , message:"with the access token secret for a set of Twitter client credentials"}, {name:"TWITTER_HASHTAG" , message:"with the value for the twitter hashtag to use when publishing tweets"}, ] for(var env of REQUIRED_ENVIRONMENT_SETTINGS) { if (!process.env[env.name]) { console.error(`Environment variable ${env.name} should be set: ${env.message}`); } else { // convenient for debug; however: this line exposes all environment variable values - including any secret values they may contain // console.log(`Environment variable ${env.name} is set to : ${process.env[env.name]}`); } }

This snippet is used in the index.js file in my Node application. This file also contains several references to process.env — that used to be hard coded values.

It seems convenient to use npm start to run the application — for example because it allows we to define environment variables as part of the application start up. When you execute npm start, npm will check the package.json file for a script with key “start”. This script will typically contain something like “node index” or “node index.js”. You can extend this script with the definition of environment variables to be applied before running the Node application, like this (taken from package.json):

"scripts": { "start": "(export KAFKA_SERVER=myserver.cloud.com && export KAFKA_TOPIC=cool-topic ) || (set KAFKA_SERVER=myserver.cloud.com && set KAFKA_TOPIC=cool-topic && set TWITTER_CONSUMER_KEY=very-secret )&& node index", … },

Note: we may have to cater for Linux and Windows environments, that treat environment variables differently.

2. Containerize the Node application

In my case, I was working on my Windows laptop, developing and testing the Node application from the Windows command line. Clearly, that is not an ideal environment for building and running a Docker container. What I have done is use Vagrant to run a Virtual Machine with Docker Engine inside. All Docker container manipulation can easily be done inside this Virtual Machine.

Check out the Vagrantfile that instructs Vagrant on leveraging VirtualBox to create and run the desired Virtual Machine. Note that the local directory that contains the Vagrantfile and from which the vagrant up command is executed is automatically shared into the VM, mounted as /vagrant.

Note: I have used this article for inspiration for this section of my article: https://nodejs.org/en/docs/guides/nodejs-docker-webapp/ .

Note 2: I use the dockerignore file to exclude files and directories in the root folder that contains the Dockerfile. Anything listed in dockerignore is not added to the build context and will not end up in the container.

A Docker container image is built using a Docker build file. The starting point of the Docker is the base image that is subsequently extended. In this case, the base image is node:10.13.0-alpine, a small and recent Node runtime environment. I create a directory /usr/src/app and have Docker set this directory as it focal point for all subsequent actions.

Docker container images are created in layers. Each build step in the Dockerfile adds a layer. If the build is rerun, only layers for steps in the Dockerfile that have changed are rerun and only changed layers are actually uploaded when the image is pushed. Therefore, it is smart to have the steps that change the most at the end of the Dockerfile. In my case, that means that the application sources should be copied to the container image at a very late stage in the build process.

First I only copy the package.json file — assuming this will not change very frequently. Immediately after copying package.json, all node modules are installed into the container image using npm install.

Only then are the application sources copied. I have chose to expose port 8080 from the container — this is an extremely arbitrary decision. However, the environment variable PORT — whose value is read in index.js using process.env.PORT — needs to correspond exactly to whatever port I expose.

Finally the instruction to to run the Node application when the container is run: npm start passed to the CMD instruction.

Here is the complete Dockerfile:

# note: run docker build in a directory that contains this Docker build file, the package.json file and all your application sources and static files # this directory should NOT contain the node-modules or any other resources that should not go into the Docker container - unless these are explicitly excluded in a .Dockerignore file! FROM node:10.13.0-alpine # Create app directory WORKDIR /usr/src/app # Install app dependencies # A wildcard is used to ensure both package.json AND package-lock.json are copied # where available (npm@5+) COPY package*.json ./ RUN npm install # Bundle app source - copy Node application from the current directory COPY . . # the application will be exposed at port 8080 ENV PORT=8080 #so we should expose that port EXPOSE 8080 # run the application, using npm start (which runs the start script in package.json) CMD [ "npm", "start" ]

Running docker build — to be exact, I run: docker build -t lucasjellema/http-to-twitter-app . — gives the following output:


The container image is created.

I can now run the container itself, for example with:

docker run -p 8090:8080 -e KAFKA_SERVER=127.1.1.1 -e KAFKA_TOPIC=topic -e TWITTER_CONSUMER_KEY=818 -e TWITTER_CONSUMER_SECRET=secret -e TWITTER_ACCESS_TOKEN_KEY=tokenkey -e TWITTER_ACCESS_TOKEN_SECRET=secret lucasjellema/http-to-twitter-app

The container is running, the app is running and at port 8090 on the Docker host should I able to access the application:http://192.168.188.120:8090/about (not: 192.168.188.120 is the IP address exposed by the Virtual Machine managed by Vagrant)

3. Build, Tag and Push the Container Image

In order to run a container on a Kubernetes cluster — or indeed on any other machine then the one on which it was built — this container must be shared or published. The easiest way of doing so is through the use of Container (Image) Registry, such as Docker Hub. In this case I simply tag the container image with the currently applicable tag of lucasjellema/http-to-twitter-app:0.9:

docker tag lucasjellema/http-to-twitter-app:latest lucasjellema/http-to-twitter-app:0.9

I then push the tagged image to the Docker Hub registry: (note: before executing this statement, I have used docker login to connect my session to the Docker Hub):

docker push lucasjellema/http-to-twitter-app:0.9

At this point, the Node application is publicly available for pull — and can be run on any Docker compatible container engine. It does not contain any secrets — all dependencies (such as Twitter credentials and Kafka configuration) needs to be injected through environment variable settings.

4. Prepare Kubernetes Resources (Pod, Service, Secrets, Namespace, Deployment)

When the Node application is running on Kubernetes it shall have a number of constituents:

  • a namespace cqrs-demo to isolate the other artifacts in their own compartment
  • two secrets to provide the sensitive and dynamic, deployment specific details regarding Kafka and regarding the Twitter client credentials
  • a Pod for a single container — with the Node application
  • a Service — to expose the Pod on an (externally) accessible endpoint and guide requests to the port exposed by the Pod
  • a Deployment http-to-twitter-app — to configure the Pod through a template that is used for scaling and redeployment

The separate namespace cqrs-demo is created with a simple kubectl command:

kubectl create namespace cqrs-demo

The two secrets are two sets of sensitive data entries. Each entry has a key and a value and the value of course is the sensitive one. In the case of the application in this article I have ensured that only the secret-objects contain sensitive information. There is no password, endpoint, credential in any other artifact. So I can freely share the other files — even on GitHub. But not the secrets files. They contain the valuable goods.

Note: even though the secrets may seem encrypted — in this case they are not. They simply contain the base64 representation of the actual values. These base64b values can easily be retrieved on the Linux command line using:

echo -n '<value>' | base64

The secrets are created from these yaml files:

apiVersion: v1 kind: Secret metadata: name: twitter-app-credentials-secret namespace: cqrs-demo type: Opaque data: CONSUMER_KEY: U0hh CONSUMER_SECRET: dT= ACCESS_TOKEN_KEY: ODk= ACCESS_TOKEN_SECRET: aUZv and apiVersion: v1 kind: Secret metadata: name: kafka-server-secret namespace: cqrs-demo type: Opaque data: kafka-server-endpoint: MTI5 kafka-topic: aWRj

using these kubectl statements:

kubectl create -f ./kafka-secret.yaml kubectl create -f ./twitter-app-credentials-secret.yaml

The Kubernetes Dashboard displays the two secrets:


And some details for one (but not the sensitive values):


The file k8s-deployment.yml contains the definition of both the service as well as the deployment and through the deployment indirectly also the pod.

The service is defined of type LoadBalancer. This results on Oracle Kubernetes Engine on a special external IP address assigned to this service. That could be considered somewhat wasteful. A more elegant approach would be to use a IngressController — that allows us to handle more than just a single service on an external IP address. For the current example, LoadBalancer will do. Note: when you run the Kubernetes artifacts on an environment that does not support LoadBalancer — such as minikube — you can change type LoadBalancer to type NodePort. A random port is then assigned to the service and the service will be available on that port on the IP address of the K8S cluster.

The service is exposed externally at port 80 — although other ports would be perfectly fine too. The service connects to the container port with the logical name app-api-port in the cqrs-demo namespace. This port is defined for the http-to-twitter-app container definition in the http-to-twitter-app deployment. Note: multiple containers can be started for this single container definition — depending on the number of replicas specified in the deployment and for example depending on the question of (re)deployments are taking place. The service mechanism ensures that traffic is load balanced across all container instances that expose the app-api-port.

kind: Service apiVersion: v1 metadata: name: http-to-twitter-app namespace: cqrs-demo labels: k8s-app: http-to-twitter-app kubernetes.io/name: http-to-twitter-app spec: selector: k8s-app: http-to-twitter-app ports: - protocol: TCP port: 80 targetPort: app-api-port type: LoadBalancer # with type LoadBalancer, an external IP will be assigned - if the K8S provider supports that capability, such as OKE # with type NodePort, a port is exposed on the cluster; whether that can be accessed or not depends on the cluster configuration; on Minikube it can be, in many other cases an IngressController may have to be configured

After creating the service, it will take some time (up to a few minutes) before an external IP address is associated with the (load balancer for the) service. The external ip will then be shown as pending. Below what it looks like in the dashboard when the external IP has been assigned although I blurred most of the actual IP address)


The deployment for now specifies just a single replica. It specifies the container image on which the container (instances) in this deployment are based: lucasjellema/http-to-twitter-app:0.9. This is of course the container image that I pushed in the previous section. The container exposes port 8080 (container port) and this port has been given the logical name app-api-port, that we have seen before.

The K8S cluster instance I was using had an issue with DNS translation from domain names to IP address. Initially, my application was not working because the url api.twitter.com could not be translated into an IP address. Instead of trying to fix this DNS issue, I have made use of a built in feature in Kubernetes called hostAliases. This feature allows we to specify DNS entries that are added at runtime to the hosts file in the container. In this case I instruct Kubernetes to inject the mapping between api.twitter.com and its IP address into the hosts file of the container.

Finally, the container template specifies a series of environment variable values. These are injected into the container when it is started. Some of the values for te environment variables are defined literally in the deployment definition. Others consist of references to entries in secrets, for example the value for TWITTER_CONSUMER_KEY that is derived from the twitter-app-credentials-secret using the CONSUMER_KEY key.

apiVersion: extensions/v1beta1 kind: Deployment metadata: labels: k8s-app: http-to-twitter-app name: http-to-twitter-app namespace: cqrs-demo spec: replicas: 1 strategy: rollingUpdate: maxSurge: 1 maxUnavailable: 1 type: RollingUpdate template: metadata: labels: k8s-app: http-to-twitter-app spec: hostAliases: - ip: "104.244.42.66" hostnames: - "api.twitter.com" containers: - image: "lucasjellema/http-to-twitter-app:0.9" imagePullPolicy: Always name: http-to-twitter-app ports: - containerPort: 8080 name: app-api-port protocol: TCP env: - name: PUBLISH_TO_KAFKA_YN value: "N" - name: TWITTER_HASHTAG value: "#GroundbreakersTourOrderEvent" - name: TWITTER_CONSUMER_KEY valueFrom: secretKeyRef: name: twitter-app-credentials-secret key: CONSUMER_KEY - name: TWITTER_CONSUMER_SECRET valueFrom: secretKeyRef: name: twitter-app-credentials-secret key: CONSUMER_SECRET - name: TWITTER_ACCESS_TOKEN_KEY valueFrom: secretKeyRef: name: twitter-app-credentials-secret key: ACCESS_TOKEN_KEY - name: TWITTER_ACCESS_TOKEN_SECRET valueFrom: secretKeyRef: name: twitter-app-credentials-secret key: ACCESS_TOKEN_SECRET - name: KAFKA_SERVER valueFrom: secretKeyRef: name: kafka-server-secret key: kafka-server-endpoint - name: KAFKA_TOPIC valueFrom: secretKeyRef: name: kafka-server-secret key: kafka-topic

The deployment in the dashboard:


Details on the Pod:


Given admin privileges, I can inspect the real values of the environment variables that were derived from secrets.

The Pod logging is easily accessed as well:

5. Run and Try Out the Application

When the external IP has been allocated to the Service and the Pod is running successfully, the application can be accessed. From the Oracle Database — and also just from any browser:


The public IP address was blurred in the location bar. Note that no Port is specified in the URL — because the port will default yo 80 and that happens to be the port defined in the service as the port to map to the container’s exposed port (8080).

When the database makes its HTTP request, we can see in the Pod logging that the request is processed:


And I can even verify that it has done what in the logging the application states it has done:

Resources

GitHub sources: https://github.com/lucasjellema/groundbreaker-japac-tour-cqrs-via-twitter-and-event-hub

Kubernetes Cheatsheet for Docker developers: https://technology.amis.nl/2018/09/26/from-docker-run-to-kubectl-apply-quick-kubernetes-cheat-sheet-for-docker-users/

Kubernetes Documentation on Secrets: https://kubernetes.io/docs/concepts/configuration/secret/

Kubernetes Docs on Host Aliases: https://kubernetes.io/docs/concepts/services-networking/add-entries-to-pod-etc-hosts-with-host-aliases/

Docker docs on dockerignore https://docs.docker.com/engine/reference/builder/#dockerignore-file

Kubernetes Docs on Deployment: https://kubernetes.io/docs/concepts/workloads/controllers/deployment/

Why Your Developer Story is Important

Tue, 2018-11-06 02:45

Stories are a window into life. They can if they resonate provide insights into our own lives or the lives of others.They can help us transmit  knowledge, pass on traditions, solve present day problems or allow us to imagine alternate realities. Open Source software is an example of an alternate reality in software development, where proprietary has been replaced in large part with sharing code that is free and open. How is this relevant to not only developers but people who work in technology? It is human nature that we continue to want to grow, learn and share.

 

With this in mind, I started 60 Second Developer Stories and tried it out at various Oracle Code One events, at Developer Conferences and now at Oracle OpenWorld 2018/Code One. For the latter we had a Video Hangout in the Groundbreakers Hub at CodeOne where anyone with a story to share could do so. We livestream the story via Periscope/Twitter and record it and edit/post it later on YouTube.  In the Video Hangout, we use a green screen and through the miracles of technology Chroma key it in and put in a cool backdrop. Below are some photos of the Video Hangout as well as the ideas we give as suggestions.

Oracle 60 Second Developer Story 2IMG_3756.JPG

Oracle 60 Second Developer Story.jpg

60 Sec with Background.png

  •     Share what you learned on your first job
  •     Share a best coding practice.
  •     Explain how  a tool or technology works
  •     What have you learned recently about building an App?
  •     Share a work related accomplishment
  •     What's the best decision you ever made?
  •     What’s the worst mistake you made and the lesson learned?
  •     What is one thing you learned from a mentor or peer that has really helped you?
  •     Any story that you want to share and community can benefit from

 

 

 

 

Here are some FAQs about the 60 Second Developer Story

 

Q1. I am too shy, and as this is live what if I get it wrong?

A1. It is your story, there is no right or wrong. If you mess up, it’s not a problem we can do a retake.

 

Q2. There are so many stories, how do I pick one?

A2. Share something specific an event that has a beginning, middle an end. Ideally there was a challenge or obstacle and you overcame it. As long as it is meaningful to you it is worth sharing.

 

Q3. What if it’s not exactly 60 seconds, if it’s shorter or longer?

A3. 60 Seconds is a guideline. I will usually show you a cue-card to let you know when you have 30 secs. and 15 secs. left. A little bit over or under is not a big deal.

 

Q4. When can I see the results?

A4. Usually immediately. Whatever Periscope/Twitter handle we are sharing on, plus if you have a personal Twitter handle, we tweet that before you go live, so it will show up on your feed.

 

Q4. What if I am not a Developer?

A5. We use Developer in a broad sense. It doesn’t matter if you are a DBA or Analyst, or whatever. If you are involved with technology and have a story to share, we want to hear it.

 

 

Here is an example of a  a 60 Second Developer Story.

We hope to have the Video Hangout at future Oracle Code and other events and look forward for you to share your 60 Second story.

New in Developer Cloud - Fn Support and Wercker Integration

Mon, 2018-11-05 12:19

Over the weekend we rolled out an update to your Oracle Developer Cloud Service instances which introduces several new features. In this blog we'll quickly review two of them - Support for the Fn project and integration with the Wercker CI/CD solution. These new features further enhance the scope of CI/CD functionality that you get in our team development platform.

Project Fn Build Support

Fn is a function-as-a-service open-source platform lead by Oracle and available for developers looking to develop portable functions with a variety of languages. If you are not familiar with Project Fn a good intro on why you should care is this blog, and you can learn more on it through the Fn project's home page on GitHub.

In the latest version of Developer Cloud you have a new option in the build steps menu that helps you define various Fn related commands as part of your build process. So for example if you Fn project code is hosted in the Git repository provided by your DevCS project, you can use the build step to automate a process of building and deploying the function you created.

Fn Build Step

Wercker/ Oracle Container Pipelines Integration

A while back Oracle purchased a docker native CI/CD solution called Wercker - which is now also offered as part of  Oracle Cloud Infrastructure under the name Oracle Container Pipelines. Wercker is focused on offering CI/CD automation for Docker & Kubernetes based micro services. As you probably know we also offer similar support for Docker and Kubernetes in Developer Cloud Service which has support for declarative definition of Docker build steps, and ability to run Kubectl scripts in its build pipelines.

If you have investment in Wercker based CI/C, and you want a more complete agile/DevOps set of features - such as the functionality offered by Developer Cloud Service (including free private Git repositories, issue tracking, agile boards and more) - now you can integrate the two solutions without loosing your investement in Wercker pipelines.

For a while now Oracle Containers Pipeline provides support for picking up the code directly from a git repository hosted in Developer Cloud Service. 

Wercker selecting DevCS

Now we added support for Developer Cloud Service to invoke pipelines you defined in Wercker directly as part of a build job and pipelines in Developer Cloud Service. Once you provide DevCS with your personal token for logging into Wercker, you can pick up specific applications, and pipelines that you would like to execute as part of your build jobs.

Wercker build step

 

There are several other new features and enhancements in this month's release of Oracle Developer Cloud you can read about those in our What's New page.

 

Making an IoT Badge – #badgelife going corporate

Thu, 2018-11-01 15:33

By Noel Portugal,  Senior Cloud Experience Developer at Oracle

 

Code Card 2018

For years I’ve been wanting to create something fun with the almighty esp8266 WiFi chip. I started experimenting with the esp8266 almost exactly four years ago. Back then there was no ArduinoLua or even MicroPython ports for the chip, only the C Espressif SDK. Today it is fairly easy to write firmware for the ESP given how many documented projects are out there.

IoT Badge by fab-lab.eu

Two years ago I was very close to actually producing something with the esp8266. We, the AppsLab team,  partnered with the Oracle Technology Network team (now known as Oracle Groundbreakers Team) to offer an IoT workshop at Oracle Open World 2016. I reached out to friend-of-the lab Guido Burger from fab-lab.eu and he came up with a clever design for an IoT badge. This badge was the swiss army knife of IoT dev badge/kits.  Unfortunately, we ran out of time to actually mass produce this badge and we had to shelve the idea.

Instead, we decided that year to use an off-the-shelf NodeMcu to introduce attendees to hardware that can talk to the Cloud. For the next year, we updated the IoT workshop curriculum to use the Wio Node board from Seeedstudio.

Fast forward to 2018.  I’ve been following emerging use cases of e-ink screens, and I started experimenting with them. Then the opportunity came.  We needed something to highlight how easy it is to deploy serverless functions with Fn project. Having a physical device that could retrieve content from the cloud and display it was the perfect answer for me.

I reached out to Squarofumi, the creators of Badgy, and we worked together to come up with the right specs for what we ended up calling the Code Card. The Code Card is an IoT badge powered by the esp8266, a rechargeable coin battery, and an e-ink display.

I suggested using the same technique I used to create my smart esp8266 button. When either button A or B are pressed it sets the esp8266 enable pin to high, then the first thing the software does is keep the pin high until we are done doing an HTTP request and updating the e-ink screen.  When we are done, we set the enable pin to low and the chip turns off (not standby). This allows the battery to last much longer.

To make it even easier for busy attendees to get started, I created a web app that was included in the official event app. The Code Card Designer lets you choose from different templates and assign them to a button press (short and long press).

You can also choose an icon from some pre-loaded icons on the firmware. Sadly at the last minute, I had to remove one of the coolest features: the ability to upload your own picture. The feature was just not very reliable and often failed. With more time the feature can be re-introduced.

After attendees used the Code Card designer they were ready for more complex stuff. All they needed to do was connect the Card to their laptops and connect via serial communication. I created a custom Electron Terminal to make it easier to access a custom CLI to change the button endpoints and SSID information.

A serverless function or any other endpoint returning the required JSON is all that is needed to start modifying your Card.

 

I published the Arduino source code along with other documentation. It didn’t take long for attendees to start messing around with c codearray images to change their icons.

Lastly, if you paid attention you can see that we added two Grove headers to connect analog or digital sensors. More fun!

Go check out and clone the whole Github repo. You can prototype your own “badge” using off-the-shelf e-ink board similar to this.

#badgelife!

Oracle Code One, Day Four Updates and Wrap Up

Fri, 2018-10-26 18:18

It’s been an educational, inspirational, and insightful four days at Oracle Code One in San Francisco. This was the first time Oracle Code One and Oracle Open World were run side-by-side.  Attendees chose from the 2500 sessions, a majority of them featuring customers and partners who overcame real-world challenges. We also had an exhibition floor with Oracle Code One partners, and the Groundbreakers Hub, where attendees toyed around with Blockchain, IoT, AI and other emerging technologies. Personally, I felt inspired by a team of high school students who used Design Thinking, thermographic cameras, and pattern recognition to help with detecting early-stage cancer.

Java Keynote

The highlight from Day 1 was the Java Keynote. Matthew McCullough from Github talked about the importance of building a development community and growing the community one developer at a time. He also shared that Java has been the 2nd most popular language on Github, behind Javascript. Rayfer Hazen, manager of the data pipelines team at Github, shared similar views on Java:

“Java’s strengths in parallelism and concurrency, its performance, its type system, and its massive ecosystem all make it a really good fit for building data infrastructure.”

Developers from Oracle then unveiled Project Skara, which can used for the code review and code management practices for the JDK (Java Development Kit).

Georges Saab, Vice President at Oracle, announced the following fulfilled commitments, which were originally made last year:

  • Making Java more open: remaining closed-source features have been contributed to Open JDK
  • Delivering enhancements and innovation faster: Oracle is adopting a predictable 6-month cadence so that developers can access new features sooner
  • Continuing support for the Java ecosystem: specific releases will be provided with LTS (long-term support)

Mark Reinhold, Chief Architect of the Java Platform then elaborated on major architectural changes to the Java. Though Oracle has moved to a six-month release cadence with certain builds supported long-term (LTS builds), he reiterated that “Java is still free.” Previously closed-source features such as Application Class-Data Sharing, Java Flight Recorder, and Java Mission Control are now available as open source. 

Mark also showcased Java’s features to improve developer productivity and program performance, in the face of evolving programming paradigms. Key projects to meet these two goals include Amber, Loom, Panama, and Valhalla.

Code One Keynote

The Code One Keynote on Tuesday was kicked-off by Amit Zavery, Executive Vice President at Oracle, who elaborated on major application trends:

  • Microservices and Serverless Architectures, which provide better infrastructure efficiency and developer productivity

  • DevSecOps, with a move to NoOps, which requires a different mindset in engineering teams

  • The importance of open source, which was also highlighted in Mark Reinhold’s talk at the Java keynote

  • The need for Digital Assistants, which provide a different interface for interaction, and a different UX requirement

  • Blockchain-based distributed transactions and ledgers

  • The importance of embedding AI/ML into applications

Amit also covered Oracle Cloud Platform’s comprehensive portfolio, which spans across the application development trends above, as well as other areas.

Dee Kumar, Vice President for Marketing and Developer Relations at CNCF, talked about digital transformation which depends on cloud native computing and open source. Per Dee, Kubernetes is second only to Linux when measured by number of authors. Dee emphasized that containerization is the first step in becoming a cloud native organization.

For organizations considering cloud native technology, the benefits of cloud native projects, per the CNCF bi-annual surveys include:

  • Faster deployment time

  • Improved scalability

  • Cloud portability

Matt Thompson, Vice President of Developer Engagement and Evangelism, hosted a session about “Building in the Cloud.” Matt Baldwin and Manish Kapur from Oracle conducted live demos featuring chatbots/digital assistants (conversational interfaces), serverless functions, and blockchain ledgers.

Groundbreaker Panel and Award Winners

Also on Tuesday, Stephen Chin led a talk on the Oracle Groundbreakers Awards through which Oracle seeks to recognize technology innovators. The Groundbreakers Award Winners for 2018 are:

  • Neha Narkhede: co-creator of Apache Kafka

  • Guido van Rossum: Creator of Python

  • Doug Cutting: Co-creator of Hadoop

  • Graeme Rocher: Creator of Grails

  • Charles Nutter: Co-creator of JRuby

In addition, Stephen recognized the Code One stars, individuals who were the best speakers at the conference, evangelists of open source and emerging technologies, and leaders in the community.

Duke’s Choice Award Winners

The Java team, represented by Georges Saab, also announced winners of the Duke’s Choice Awards, which were given to top projects and individuals in the Java community. Award winners included:

Customer Spotlight

We had customers join us to talk further about their use of Oracle Cloud Platform:

  • Mitsubishi Electric: Leveraged Oracle Cloud for AI, IoT, SaaS, and PaaS to achieve 60% increase in operating rate, 55% decrease in manual processes, and 85% reduction in floor space

  • CargoSmart: Used Blockchain to integrate custom ERP and Supply Chain on Oracle Database. Achieved 65% reduction in time taken to collect, consolidate, and confirm data.

  • AllianceData: Moved over 6TB to Oracle Cloud Infrastructure – PeopleSoft, EPM, Exadata, and Windows, thereby saving $1M/year in licensing and support

  • AkerBP: Achieved elastic scalability with Oracle Cloud, running reports in seconds instead of 20 minutes and eliminating downtimes due to database patching

Groundbreakers Hub

The Groundbreakers Hub featured a number of interesting demos on AI and chatbots, personalized manufacturing leveraging Oracle’s IoT Cloud, robotics, and even early-stage cancer detection. Here are some of the highlights.

Personalized Manufacturing using Oracle IoT Cloud

This was one of the most popular areas in the Hub. Here is how the demo worked:

  • A robotic arm grabbed a piece of inventory (a coaster) using a camera. The camera used computer vision to detect placement of the coaster.

  • The arm then moved across and dropped the coaster onto a conveyer belt

  • The belt moved past a laser engraver, which engraves custom text, like your name, on the coaster

Oracle Cloud, including IoT Cloud and SCM (Supply Chain Management) Cloud, were leveraged through this process to monitor the production equipment, inventory and engraving. Check out the video clip below.

3D Rendering with Raspberry Pis and Oracle Cloud

Another cool spot was the “Bullet Time” photo booth. Using fifty Rasperry Pis equipped with cameras, images were captured around me. These images were then sent to the Oracle Cloud to be stitched together. The final output -- a video -- was sent to me via SMS.

Cancer Detection by High School Students

We also had high school students from DesignTech, which is supported by the Oracle Education Foundation. Among many projects, these students created a device to detect early-stage cancer using a thermographic (heat-sensitive) camera and a touchscreen display. An impressive high school project!

Summary

Java continues to be a leading development language, and is used extensively at companies such as Github. To keep pace with innovation in the industry, Java is moving to a 6-month release cadence. Oracle has a keen interest in emerging technologies, such as AI/ML, Blockchain, Containers, Serverless Functions and DevSecOps/NoOps. Oracle recognized innovators and leaders in the industry through the Groundbreakers Awards and Duke’s Choice Awards.

That’s just some of the highlights from Oracle Code One 2018. We look forward to seeing you next time!

 

All Things Developer at Oracle Code One - Day 3

Thu, 2018-10-25 15:25

 

Community Matters! The Code One Avengers Keynote. When it comes to a code conference, it has to be about the community. Stephen Chin and his superheroes proved that right on stage last night with their Code Avengers keynote. The action-packed superheroes stole the thunder of Code One on Day 3.

Some of us were backstage with the superheroes, and the excitement and energy were just phenomenal. We want to tell this story in pictures, but what are these avengers fighting for?

We will, of course, start with Dr. Strange's address to his fellow superheroes of code which brought more than a quarter million viewers on Twitter. And then his troupe follows! The mural comic strips, animations, screenplay, and cast came together just brilliantly! Congrats to the entire superheroes team!

Here are some highlights from the keynote to recap:

https://www.facebook.com/OracleCodeOne/videos/2486105168071342/

The Oracle Code One Team Heads to CloudFest18

The remaining thunder was stolen by the Portugal Man, the Beck, and the Bleachers at the CloudFest18 rock concert in AT&Park. Jam-packed with Oracle customers, employees, and partners from TCS, the park was just electric with Powerade music!

Hands-on Labs Kept Rolling!

The NoSQL hands-on lab in action here delivered by the crew. One API to many NoSQL databases!

The Groundbreakers Hub was Busy!

The Hub was busy with pepper, more Groundbreaker live interviews, video hangouts, Zip labs, Code Card pickups, bullet time photo booths, superhero escape rooms, hackergarten, and with our favorite Cloud DJ  - Sonic Pi! Stephen Chin recaps what's hot at the Hub right here.

And a quick run of the bullet time photo booth. Rex Wang in action!

Sam Craft, our first Zip lab winner!

Code One Content in Action

Click here for a quick 30 second recap of other things on Day 3 at Oracle Code One.

Groundbreaker live interviews with Jesse Butler and Karthik Gaekwad on cloud native technologies and the Fn project -

https://twitter.com/OracleDevs/status/1055169708192751616

Groundbreaker live interview on AI and ML

https://twitter.com/OracleDevs/status/1055183021316292608

Groundbreaker live interviews on building RESTful APIs - 

https://twitter.com/OracleDevs/status/1055230551324483584

Groundbreaker live interviews with the design tech school on The All Jacked Up Project - 

https://twitter.com/OracleDevs/status/1055224092456960000

Groundbreaker live interviews on NetBeans

https://twitter.com/OracleDevs/status/1055206463809843200

And interesting live video hangouts on diversity in tech and women in tech

https://twitter.com/groundbreakers/status/1055161816333017088

https://twitter.com/groundbreakers/status/1055147716903239681

All Things Developer at Oracle Code One - Day 2

Wed, 2018-10-24 02:27
Live from Oracle Code One - Day Two

There was tons of action today at Oracle Code One. From Zip labs and challenges to an all-women developer community breakfast,  and the Duke Choice awards, to the Oracle Code keynotes and the debut Groundbreaker awards, it was all happening at Code One. Pepper was quite busy, and so was the blockchain beer bar!

Zip Labs, Zip Lab Challenges and Hands-on Labs

Zip labs are running all four days. So, if you want to dabble with the Oracle Cloud, or learn how you can provision the various services, go up to the second floor on Moscone West and sign-up for our cloud.

You can sign-in for a 15-minute lab challenge on Oracle Cloud content and see your name on the leaderboard as the person to beat. Choose from labs including Oracle Autonomous Data Warehouse, Oracle Autonomous Transaction Processing, and Virtual Machines.

Lots of ongoing hands-on labs everyday but the Container Native labs today were quite a hit.

Oracle Women's Leadership Developer Community Breakfast

A breakfast this morning with several women developers from across the globe. It was quite insightful to learn about their life and experiences in code.

The Duke Choice Awards and Groundbreaker Live Interviews

Georges Saab announced the Duke Choice Award winners at Code One today. 

Some exciting Groundbreaker live interviews:

Jim Grisanzio and Gerald Venzl talk about Oracle Autonomous Database

Bob Rubhart, Ashley Sullivan and the Design Tech Students discuss the Vida Cam Project

The Oracle Code One Keynotes and Groundbreaker Awards in Pictures

Building Next-Gen Cloud Native Apps with Embedded Intelligence, Chatbots, and Containers: Amit Zavery, Executive Vice President, PaaS Development, Oracle talks about how developers can leverage the power of the Oracle cloud.

Making Cloud Native Computing Universal and Sustainably Harnessing the Power of Open Source: Dee Kumar, Vice President, Cloud Native Computing Foundation congratulates Oracle on successfully becoming a Platinum member of CNCF.

 

 

Building for the Cloud: Matt Thompson, Developer Engagement and Evangelism, Oracle Cloud Platform talks about how a cloud works best - when it is open, secure, and all things productive for the developer. 

 

 

 

Demos: Serverless, Chatbots, Blockchain...

 

Manish Kapur, Director of Product Management for Cloud Platform showed a cool demo of a new serverless/microservices based cloud architecture for selling and buying a car.

 

 

Matt Baldwin talked about the DNA of Blockchain and how it is used in the context of selling and buying a car.

 

 

And the Oracle Code One Groundbreaker Awards go to:

 

Stephen Chin, Director of Developer Community, announces the debut Groundbreaker awards and moderates a star panel with the winners.

 

 

We had more than 200K viewers of this panel on the Oracle Code One Twitter live stream today! There were lots of interesting and diverse questions for the panel from the Oracle Groundbreaker Twitter channel. For more information on Oracle Groundbreakers, click here. And now, moving on to  Day 3 of Code One!

 

Oracle Database 18c XE on Oracle Cloud Infrastructure: A Mere Yum Install Away

Tue, 2018-10-23 14:38

It's a busy week at OpenWorld 2018. So busy, that we didn't get around to mentioning that Oracle Database 18c Express Edition now available on Oracle Cloud Infrastructure (OCI) yum servers! This means it's easy to install this full-features Oracle Database for developers on an OCI compute shape without incurring any extra networking charges. In this blog post I demonstrate how to install, configure and connect to Oracle Database 18c XE OCI.

Installing Oracle Database 18c XE on Oracle Cloud Infrastructure

From a compute shape in OCI, grab the latest version of the repo definition from the yum server local to your region as follows:

cd /etc/yum.repos.d sudo mv public-yum-ol7.repo public-yum-ol7.repo.bak export REGION=`curl http://169.254.169.254/opc/v1/instance/ -s | jq -r '.region'| cut -d '-' -f 2` sudo -E wget http://yum-$REGION.oracle.com/yum-$REGION-ol7.repo

Enable the ol7_oci_included repo:

sudo yum-config-manager --enable ol7_oci_included

Here you see the Oracle Database 18c XE RPM is available in the yum repositories:

$ yum info oracle-database-xe-18c Loaded plugins: langpacks, ulninfo Available Packages Name : oracle-database-xe-18c Arch : x86_64 Version : 1.0 Release : 1 Size : 2.4 G Repo : ol7_oci_included/x86_64 Summary : Oracle 18c Express Edition Database URL : http://www.oracle.com License : Oracle Corporation Description : Oracle 18c Express Edition Database

Let's install it.

$ sudo yum install $ yum info oracle-database-xe-18c Loaded plugins: langpacks, ulninfo No package $ available. Package yum-3.4.3-158.0.2.el7.noarch already installed and latest version Package info-5.1-5.el7.x86_64 already installed and latest version Resolving Dependencies --> Running transaction check ---> Package oracle-database-xe-18c.x86_64 0:1.0-1 will be installed --> Finished Dependency Resolution Dependencies Resolved ========================================================================================================= Package Arch Version Repository Size ========================================================================================================= Installing: oracle-database-xe-18c x86_64 1.0-1 ol7_oci_included 2.4 G Transaction Summary ========================================================================================================= Install 1 Package Total download size: 2.4 G Installed size: 5.2 G Is this ok [y/d/N]: y Downloading packages: oracle-database-xe-18c-1.0-1.x86_64.rpm | 2.4 GB 00:01:13 Running transaction check Running transaction test Transaction test succeeded Running transaction Installing : oracle-database-xe-18c-1.0-1.x86_64 1/1 [INFO] Executing post installation scripts... [INFO] Oracle home installed successfully and ready to be configured. To configure Oracle Database XE, optionally modify the parameters in '/etc/sysconfig/oracle-xe-18c.conf' and then execute '/etc/init.d/oracle-xe-18c configure' as root. Verifying : oracle-database-xe-18c-1.0-1.x86_64 1/1 Installed: oracle-database-xe-18c.x86_64 0:1.0-1 Complete! $ Configuring Oracle Database 18c XE

With the software now installed, the next step is to configure it:

$ sudo /etc/init.d/oracle-xe-18c configure Specify a password to be used for database accounts. Oracle recommends that the password entered should be at least 8 characters in length, contain at least 1 uppercase character, 1 lower case character and 1 digit [0-9]. Note that the same password will be used for SYS, SYSTEM and PDBADMIN accounts: Confirm the password: Configuring Oracle Listener. Listener configuration succeeded. Configuring Oracle Database XE. Enter SYS user password: ************** Enter SYSTEM user password: ************ Enter PDBADMIN User Password: ************** Prepare for db operation 7% complete Copying database files 29% complete Creating and starting Oracle instance 30% complete 31% complete 34% complete 38% complete 41% complete 43% complete Completing Database Creation 47% complete 50% complete Creating Pluggable Databases 54% complete 71% complete Executing Post Configuration Actions 93% complete Running Custom Scripts 100% complete Database creation complete. For details check the logfiles at: /opt/oracle/cfgtoollogs/dbca/XE. Database Information: Global Database Name:XE System Identifier(SID):XE Look at the log file "/opt/oracle/cfgtoollogs/dbca/XE/XE.log" for further details. Connect to Oracle Database using one of the connect strings: Pluggable database: instance-20181023-1035/XEPDB1 Multitenant container database: instance-20181023-1035 Use https://localhost:5500/em to access Oracle Enterprise Manager for Oracle Database XE Connecting to Oracle Database 18c XE

To connect to the database, use the oraenv script to set the necessary environment variables, entering the XE as the ORACLE_SID.

$ . oraenv ORACLE_SID = [opc] ? XE ORACLE_BASE environment variable is not being set since this information is not available for the current user ID opc. You can set ORACLE_BASE manually if it is required. Resetting ORACLE_BASE to its previous value or ORACLE_HOME The Oracle base has been set to /opt/oracle/product/18c/dbhomeXE $

Then, connect as usual using sqlplus: $ sqlplus sys/OpenWorld2018 as sysdba SQL*Plus: Release 18.0.0.0.0 - Production on Tue Oct 23 19:13:23 2018 Version 18.4.0.0.0 Copyright (c) 1982, 2018, Oracle. All rights reserved. Connected to: Oracle Database 18c Express Edition Release 18.0.0.0.0 - Production Version 18.4.0.0.0 SQL> select 1 from dual; 1 ---------- 1 SQL> Conclusion

Whether you are a developer looking to get started quickly with building applications on your own full-featured Oracle Database, or an ISV prototyping solutions that require an embedded database, installing Oracle Database XE on OCI is an excellent way to get started. With Oracle Datbase 18c XE available as an RPM inside OCI via yum, it doesn't get any easier.

All Things Developer at Oracle CodeOne - Day 1 Recap

Tue, 2018-10-23 00:45

Live from Oracle CodeOne - Day One

A lot of action, energy, and fun here on the first day at Oracle CodeOne 2018. From all the fun at the Developers Exchange to the cool things at the Groundbreakers hub, we've covered it all for you! So, let's get started! 

Here's a one minute recap that tells the day one story, in well, a minute!

The Groundbreakers Hub.

We announced a new developer brand at Oracle CodeOne today, and it is...the Groundbreaker's Hub - yes, you got it! Groundbreakers is the lounge for developers, the nerds, the geeks and also the tech enthusiasts. Anyone who wants to hang out with the fellow developer community.

There's the Groundbreaker live stage where we got customers talking about their experience with the Oracle Cloud, and we got over 30 great stories on record today. Kudos to the interviewers - Javed Mohammed and Bob Rhubart.

The video hangouts was a casual, sassy corner to share stories of the code you built, the best app you created, the best developer you met, or the most compelling lesson you've ever learned. 

Don't forget to chat with Pepper, our chatbot that will tell you what's on at CodeOne or anything at all.

Also, check out the commit mural that commemorates the first annual CodeOne and the new Groundbreaker community.

There's some blockchain beer action too! Select the beer you want to taste using the Blockchain app and learn all about its origins! 

The Keynotes and Sessions

Keynote: The Future of Java is Today

The BIG keynote first! The Future of Java is today! An all things Java keynote by Mark Reinhold (Chief Architect of Java Platform Group at Oracle), and Georges Saab (VP Development at Oracle). It's a full house of developers who flocked to a very informative session on the evolution of Java to meet the needs of developers to become more secure, stable, and rich.

 A lot of insight into the new enhancements around Java with recent additions to languages and the platform. Matthew McCullough (Vice President of Field Services, GitHub) and Rafer Hazen (Data Pipelines Engineering Manager, GitHub) also talked about GitHub, Java, and the OpenJDK Collaboration. 

We streamed this live via our social channels with a viewership about half a million developers worldwide!! Here are some snippets of the backstage excitement from the crew.

Big Session Today: Emerging Trends and Technologies with Modern App Dev

Siddhartha Agarwal took the audience through all things app dev at Oracle - Cloud-native application development, DevSecOps, AI and conversational AI, Open Source software, Blockchain platform and more!

And he was supported by Suhas Uliyar, (VP, Bot AI and Mobile Product Management), and Manish Kapur (Director of App Dev, Product Management) to tell this modern app dev story via demos.

The Developer's Exchange

Lots of good tech (and swag) on the Oracle Developers Exchange floor that developers could flock to. Pivotal, JFrog, IBM, Redhat, AppDynamics, DataDog...the list goes on. But check out a few fashionable. booths right here.

Now, onto day two - Tuesday (10/23) ! Lots of keynotes, fireside chats, DJ and music, demos, hubs, and labs await! Thanks to Anaplan. They provided delicious free food, snacks, and drinks to all the visitors who checked-in with them!

 

All Things Developer at Oracle CodeOne. Spotlight APIs.

Fri, 2018-10-19 20:59
Code One - It’s Here!

We’re just a few days away from Oracle’s biggest conference for Developers that’s now known as Code One. Java One morphed into Code One to extend support for more developer ecosystems - languages, open-source projects, and cloud-native foundations. So, first, the plugs - if you’d like to be a part of the Oracle Code One movement and have not already registered, you can still do it. You can get lost, yes! It’s a large conference with lots of sessions and other moving parts. But we’ve tried to make things simple for you here to plan your calendar. Look through these to find the right tracks and session types for you. 

There are some exciting keynotes you don’t want to miss - The Future of Java, the Power of Open Source, and Building Next-Gen Could Native Apps using Emerging Tech, the Ground Breaker Code Avenger sessions, and Fireside chats! And now for the fun stuff, cause our conference is not complete without that - there’s the Cloud Fest! Get ready to be up all night with Beck; Portugal; the Man; and the Bleachers. And if you are up, get your nerdy kids to the code camp over the weekend. It’s Oracle Code for Kids time inspiring the next generation of developers!

The prelude to Code One wouldn’t be complete without talking about the Groundbreaker’s Hub. A few things that you HAVE to check out are: the Blockchain Beer - Try beers that were mixed using Blockchain technology that enabled the microbrewery to accurately estimate the correct combination of raw materials to create different types of beer. Then vote for your favorite beer on our mobile app - it’s pretty cool! Experience the bullet time photo booth, the chatbot with pepper, code card ( IoT card that you can program using Fn project serverless technologies. It will have a wifi embedded chip, e-link screen, and a few fun buttons). Catch all the hub action if you're there!

The Tech that Matters to Developers: Powerful APIs

We’ve talked about a lot of tech here, but there are a few things that are closer to the developer’s heart! Things that make their life more straightforward, and stuff that they use on an every hour basis. And one such technology is API. I am not going to explain what APIs are because if you are a developer, you know this. APIs are a mechanism that help to dial down on the heavy duty code and add powerful functionality to a website, app, or platform, without extensive coding, and only including the API code - there I said it.

But even for developers, it is essential to understand the system of engagement around designing and maintaining sound and healthy APIs. The cleaner the API, the better the associated user experience and performance of the app or platform in contention. Since APIs are reusable, it is essential to understand what goes into making the API an excellent one. And different types of APIs require a different type of love. 

API Strategy with Business Outcomes

First, there is a class of APIs that are powering the chatbots, and the digital experience of customers and the UX becomes one of the most significant driving factors. Second, APIs help to monetize existing data and assets. Here’s where there are organizations with API as a product and dealing with performance, scale, policy and governance around them so that the consumers have an API 360 experience. 

Third and fourth - APIs are used for operational efficiency and cost savings, and they are also used for creating exchange/app systems like the app stores!  So now, taking these four areas and establishing a business outcome is critical to driving the API strategy. And the API strategy entails good design as you’ll hear in Robert’s podcast below.

Design Matters Podcast by Robert Wunderlich

Beyond Design - Detailing the API Lifecycle

Once you have followed the principles of good API Design and established the documentation based on the business outcome, it then literally comes to the lifecycle management - the building, deployment, governance, and then managing them for scale and performance, and looping back the analytics to deliver the right expected experience. And then on the other side, there is the consumption, where developers now should be able to discover these APIs and start using them. 

And then there’s the Oracle way with APIs. Vikas Anand, VP of Product Management for SOA, Integration, and API Cloud tells how this happens.

API 360 Podcast by Vikas Anand

API Action at Code One

A lot is happening there! Hear from the customers directly on how Oracle’s API Cloud has helped to design and manage world-class APIs. Here are a few do-not-miss sessions, but you can always visit the Oracle Code page to discover more. See you there!

How Rabobank is using APICS to Achieve API Success

How RTD Connexions and Graco are using the API Success

How Ikea is using APICS to Achieve API Success 

Keynote: AI Powered Autonomous Integration Cloud and API Cloud Service

API Evolution Challenges by NFL

Evolutionary Tales of API by NFL

Vector API for Java by Netflix

Using Kubernetes in Hybrid Clouds -- Join Us @ Oracle OpenWorld

Thu, 2018-10-18 21:03

By now you have probably heard of the term cloud native. Cloud Native Computing Foundation (CNCF) defines cloud native as a set of technologies that “empower organizations to build and run scalable applications in modern, dynamic environments such as public, private, and hybrid clouds.” Cloud native is characterized by the use of containers and small, modular services – microservices -- which are managed by orchestration software.

In the following blog post, we will cover the relationship between Containers, Kubernetes and Hybrid Clouds. For more on this topic, please join us at Oracle OpenWorld for Kubernetes in an Oracle Hybrid Cloud [BUS5722].

Containers and Kubernetes

In the most recent CNCF survey among 2400 respondents, use of cloud native technologies in production has grown to over 200%, and 45% of companies run 250 or more containers.

Leveraging many containerized applications requires orchestration software that can run, deploy, scale, monitor, manage, and provide high availability for hundreds or thousands of microservices. These microservices are easier and faster to develop and upgrade since development and updates of each microservice can be independently completed, without affecting the overall application. Once a new version of a microservice is tested, it can then be pushed into production to replace the existing version without any downtime.

Hybrid Clouds

Hybrid clouds can reduce downtime and ensure application availability. For example, in a hybrid cloud model you can leverage an on-premises datacenter for your production workloads, and leverage Availability Domains in Oracle Cloud for your DR deployments to ensure that business operations are not affected by a disaster. Whereas in a traditional on-premises datacenter model you would hire staff to manage each of your geographically dispersed datacenters, you can now offload the maintenance of infrastructure and software to a public cloud vendor such as Oracle Cloud. In turn, this reduces your operational costs of managing multiple datacenter environments.

Why Kubernetes and Hybrid Clouds are like Peanut Butter and Jelly

To make the best use of a hybrid cloud, you need to be able to easily package an application so that it can be deployed anywhere, i.e. you need portability. Docker containers provide the easiest way to do this since they package the application and its dependencies to be run in any environment, on-premises datacenters or public clouds. At the same time, they are more efficient than virtual machines (VMs) as they require less compute, memory, and storage resources. This makes them more economical and faster to deploy than VMs.

Oracle’s Solution for Hybrid Clouds

Oracle Cloud is a public cloud offering that offers multiple services for containers, including Oracle Container Engine for Kubernetes (OKE). OKE is certified by CNCF, and is managed and maintained by Oracle. With OKE, you can get started with a continuously up to date container orchestration platform quickly – just bring your container apps. For hybrid use cases, you can couple Kubernetes in your data center with OKE, and then move workloads or mix workloads as needed.

To get more details and real-world insight with OKE and hybrid use cases, please join us at Oracle OpenWorld for the following session where Jason Looney from Beeline will be presenting with David Cabelus from Oracle Product Management:

Kubernetes in an Oracle Hybrid Cloud [BUS5722]

Wednesday, Oct 24, 4:45 p.m. - 5:30 p.m. | Moscone South - Room 160

David Cabelus, Senior Principal Product Manager, Oracle

Jason Looney, VP of Enterprise Architecture, Beeline

Podcast: On Microservices Design and Implementation

Tue, 2018-10-16 23:00

"Like buying a Ferrari and towing it around with a horse."

That's how Java Champion and Microservices Patterns (Manning Publications) author Chris Richardson describes the approach some organizations take to implementing microservices. It's often a matter of faulty motivation. 

In helping organizations around the world get started with microservices, the first question Chris asks his clients is, "Why do you want microservices?" The responses are often surprising. "I've talked to people who viewed microservices as magic pixie dust. You sprinkle it on things and everything will be better," Chris reports.

Another problem is the mistaken belief that the goal is microservices. "Microservices is a means to an end," Chris says. From a DevOps perspective, "there are two really good metrics," Chris explains. "One of them is deployment frequency, how often you're deploying into production. The other one is lead time, the time from commit to deploy. To me, those are the two metrics that you should be optimizing. Microservices is the way to get there."

Oracle Developer Champion Lucas Jellema, CTO and consulting IT architect with AMIS Services, also advises against diving blindly into microservices. "First step back and consider why you are thinking about microservices in the first place," Lucas says. "You choose microservices because there are issues you want to overcome, challenges you want to deal with. In the end, the only thing that really matters is that IT provides business value, and you can only provide business value if you have properly running applications that provide you with the right business functionality. The typical challenge that we try to address using microservices is to evolve that functionality in an agile fashion without much effort and without too much cost. If microservices can help with that then we want to have them. But we don't want to have them because everyone is talking about them."

Fellow Developer Champion Luis Weir, CTO of the Oracle Practice at Capgemini sees the human factor as the greatest challenge in microservice adoption and development. One of his customers has "a very clear need to implement this style of architecture," Luis says. "But it's been a nightmare to align the teams and make them work in a way that's aligned with the this architecture style, as opposed to operating in a very traditional ITL style where you need to handoff between three different teams and and do everything in a waterfall way."

Luis finds that many organizations are stuck in the past. "Not all organizations are into the DevOps way of doing things," Luis explains. Some departments may be adopting agile practices and the like. "But the IT side of the organization, in many cases, is not. They're trying to digitalize a lot of legacy. So it's a little more complicated. You're dealing with people, educating them on how to become more agile or how to think about breaking an elephant into smaller pieces." Luis admits that it's not easy.

What makes the transition so challenging, according to Oracle ACE Sven Bernhardt, a solution architect with OPITZ Consulting, is the need for "total cultural change" within the organization. "They must embrace the adaptability, the changeability. They must have a different fault tolerance, a different culture for dealing with software failures and also with failures on decisions with respect to technologies which are used for implementing a specific business functionality as a microservice," Sven explains. Too many organizations underestimate the necessary cultural change, and find that switching to a DevOps mindset is tough slog. 

But that's just a fraction of what you'll learn in this podcast, as the panel addresses ways to meet the various challenges found in getting to microservices. Listen!

BTW: Each of the panelists will present sessions are Oracle Code One and Oracle OpenWorld 2018. See the list of sessions, below. 

The Panelists

Listed alphabetically

Sven Bernhardt
Oracle ACE
Solution Architect, OPITZ Consulting
Twitter LinkedIn

Code One Sessions
  • Integration Reloaded: Integration Solutions Based on Reactive Principles [DEV5306]
    With Arturo Viveros, Principal Consultant, Sysco AS
    Thursday, Oct 25, 11:00 a.m. - 11:45 a.m. | Moscone West - Room 2008
  • Implementing a Low TCO Poly-Cloud Microservices Solution with Oracle Cloud [BUS2272]
    With Lucas Jellema, CTO, AMIS Services BV
    José Rodrigues, BPM And Webcenter Business Manager, Link Consulting
    Monday, Oct 22, 5:45 p.m. - 6:30 p.m. | Marriott Marquis (Golden Gate Level) - Golden Gate C2
Lucas Jellema
Oracle Developer Champion
Oracle ACE Director
CTO, Consulting IT Architect, AMIS Services
Twitter LinkedIn  

Code One Sessions
  • A Cloud- and Container-Based Approach to Microservices-Powered Workflows [BOF4977]
    Tuesday, Oct 23, 7:30 p.m. - 8:15 p.m. | Moscone West - Room 2006
  • 50 Shades of Data: How, When, Why—Big, Relational, NoSQL, Elastic, Graph, Event [DEV4976]
    Monday, Oct 22, 10:30 a.m. - 11:15 a.m. | Moscone West - Room 2007
  • Implementing Microservices on Oracle Cloud: Open, Manageable, Polyglot, and Scalable [BOF4978]
    Monday, Oct 22, 7:30 p.m. - 8:15 p.m. | Moscone West - Room 2012
  • Oracle Cloud Soaring: Live Demo of a Poly-Cloud Microservices Implementation [DEV4979]
    With Guido Schmutz, Principal Consultant - Technology Mangager, Trivadis AG
    Luis Weir, CTO - Oracle Practice, Capgemini UK Plc
    Wednesday, Oct 24, 2:30 p.m. - 3:15 p.m. | Moscone West - Room 2018
  • Implementing a Low TCO Poly-Cloud Microservices Solution with Oracle Cloud [BUS2272]
    With Sven Bernhardt, Solution Architect, OPITZ Consulting
    José Rodrigues, BPM And Webcenter Business Manager, Link Consulting
    Monday, Oct 22, 5:45 p.m. - 6:30 p.m. | Marriott Marquis (Golden Gate Level) - Golden Gate C2
Chris Richardson
Java Champion
Founder, Eventuate, Inc.
Twitter LinkedIn  

Code One Session
  • Developing Asynchronous, Message-Driven Microservices [DEV5252]
    Wednesday, Oct 24, 11:30 a.m. - 12:15 p.m. | Moscone West - Room 2001
Luis Weir
Oracle Developer Champion
Oracle ACE Director
CTO, Oracle Practice, Capgemini
Twitter LinkedIn  

Code One Sessions
  • The Seven Deadly Sins of API Design [DEV4921]
    Tuesday, Oct 23, 4:00 p.m. - 4:45 p.m. | Moscone West - Room 2020
  • Oracle Cloud Soaring: Live Demo of a Poly-Cloud Microservices Implementation [DEV4979]
    With Lucas Jellema, CTO, AMIS Services BV
    Guido Schmutz, Principal Consultant - Technology Mangager, Trivadis AG
    Wednesday, Oct 24, 2:30 p.m. - 3:15 p.m. | Moscone West - Room 2018
Additional Resources Coming Soon

Groundbreakers Neha Narkhede, Charles Nutter, Graeme Rocher, Guido van Rossum Guido van Rossum, and Doug Cutting examine the forces shaping IT in this special panel discussion recorded at Oracle Code One.

Subscribe

Never miss an episode! The Oracle Developer Community Podcast is available via:

Get going quickly with Command Line Interface for Oracle Cloud Infrastructure using Docker container

Sat, 2018-10-13 19:30

Originally published at technology.amis.nl on October 14, 2018.

Oracle Cloud Infrastructure is Oracle’s second generation infrastructure as a service offering — that support many components including compute nodes, networks, storage, Kubernetes clusters and Database as a Service. Oracle Cloud Infrastructure can be administered through a GUI — a browser based console — as well as through a REST API and with the OCI Command Line Interface. Oracle offers a Terraform provider that allows automated, scripted provisioning of OCI artefacts.

This article describes an easy approach to get going with the Command Line Interface for Oracle Cloud Infrastructure — using the oci-cli Docker image. Using a Docker container image and a simple configuration file, oci commands can be executed without locally having to install and update the OCI Command Line Interface (and the Python runtime environment) itself.

These are the steps to get going on a Linux or Mac Host that contains a Docker engine:

  • create a new user in OCI (or use an existing user) with appropriate privileges; you need the OCID for the user
  • also make sure you have the name of the region and the OCID for the tenancy on OCI
  • execute a docker run command to prepare the OCI CLI configuration file
  • update the user in OCI with the public key created by the OCI CLI setup action
  • edit the .profile to associate the oci command line instruction on the Docker host with running the OCI CLI Docker image

At that point, you can locally run any OCI CLI command against the specified user and tenant — using nothing but the Docker container that contains the latest version of the OCI CLI and the required runtime dependencies.

In more detail, the steps look like this:

Create a new user in OCI

(or use an existing user) with appropriate privileges; you need the OCID for the user

You can reuse an existing user or create a fresh one — which is what I did. This step I performed in the OCI Console:


I then added this user to the group Administrators.


And I noted the OCID for this user:


also make sure you have the name of the region and the OCID for the tenancy on OCI:

Execute a docker run command to prepare the OCI CLI configuration file

On the Docker host machine, create a directory to hold the OCI CLI configuration files. These files will be made available to the CLI tool by mounting the directory into the Docker container.

mkdir ~/.oci

Run the following Docker command:

docker run --rm --mount type=bind,source=$HOME/.oci,target=/root/.oci -it stephenpearson/oci-cli:latest setup config

This starts the OCI CLI container in interactive mode — with the ~/.oci directory mounted into the container at /root/oci — the and executes the setup config command on the OCI CLI (see https://docs.cloud.oracle.com/iaas/tools/oci-cli/latest/oci_cli_docs/cmdref/setup/config.html).

This command will start a dialog that results in the OCI Config file being written to /root/.oci inside the container and to ~/.oci on the Docker host. The dialog also result in a private and public key file, in that same dircetory.


Here is the content of the config file that the dialog has generated on the Docker host:

Update the user in OCI with the public key created by the OCI CLI setup action

The contents of the file that contains the public key — ~/.oci/oci_api_key_public.pem in this case — should be configured on the OCI user — kubie in this case — as API Key:

  Create shortcut command for OCI CLI on Docker host

We did not install the OCI CLI on the Docker host — but we can still make it possible to run the CLI commands as if we did. If we edit the .profile file to associate the oci command line instruction on the Docker host with running the OCI CLI Docker image, we get the same experience on the host command line as if we did install the OCI CLI.

Edit ~/.profile and add this line:

oci() { docker run --rm --mount type=bind,source=$HOME/.oci,target=/root/.oci stephenpearson/oci-cli:latest "$@"; }

On the docker host I can now run oci cli commands (that will be sent to the docker container that uses the configuration in ~/.oci for connecting to the OCI instance)

Run OCI CLI command on the Host

We are now set to run OCI CLI command — even though we did not actually install the OCI CLI and the Python runtime environment.

Note: most commands we run will require us to pass the Compartment Id of the OCI Compartment against which we want to perform an action. It is convenient to set an environment variable with the Compartment OCID value and then refer in all cli commands to the variable.

For example:

export COMPARTMENT_ID=ocid1.tenancy.oc1..aaaaaaaaot3ihdt

Now to list all policies in this compartment:

oci iam policy list --compartment-id $COMPARTMENT_ID --all

And to create a new policy — one that I need in order to provision a Kubernetes cluster:

oci iam policy create --name oke-service --compartment-id $COMPARTMENT_ID --statements '[ "allow service OKE to manage all-re sources in tenancy"]' --description 'policy for granting rights on OKE to manage cluster resources'

Or to create a new compartment:

oci iam compartment create --compartment-id $COMPARTMENT_ID --name oke-compartment --description "Compartment for OCI resources created for OKE Cluster"

From here on, it is just regular OCI CLI work, just as if it had been installed locally. But by using the Docker container, we keep our system tidy and we can easily benefit from the latest version of the OCI CLI at all times.

Resources
OCI CLI Command Reference — https://docs.cloud.oracle.com/iaas/tools/oci-cli/latest/oci_cli_docs/index.html

Terraform Provider for OCI: https://www.terraform.io/docs/providers/oci/index.html

GitHub repo for OCI CLI Docker — https://github.com/stephenpearson/oci-cli

Matrix Bullet Time Demo Take Two

Fri, 2018-10-12 10:57

By Christopher Bensen and Noel Portugal, Cloud Experience Developers

If you are attending Oracle Code One or Open World 2018, you will be happy to hear that the Matrix Bullet Time Demo will be there. You can experience it by coming to Moscone West in the Developer Exchange and inside the GroundBreakers Hub.

Last year we went into the challenges of building the Matrix Bullet Time Demo (https://developer.oracle.com/java/bullet-time). A lot of problems were encountered after that article was published so this year we pulled the demo out of storage, dusted it off and began refurbishing the demo so it could make a comeback. The first challenge was trying to remember how it all worked.

Let’s backup a bit and describe what we’ve built here so you don’t have to read the previous article. The idea is to create a demo that takes a simultaneous photo from camera’s placed around a subject, stitch these photos together and form a movie. The intended final effect is for it to appear as though the camera is moving around a subject frozen in time. To do this we used 60 individual Raspberry Pi 3 single-board computers with Raspberry Pi cameras.

Besides all of the technical challenges, there are some logistical challenges. When setup, the demo is huge! It forms a ten foot diameter circle and needs even more space for the mounting system. Not only is it huge, it’s delicate. Wires big and small are going everywhere. 15 Raspberry Pi 3s are mounted to each of the four lighting track gantries, and they are precarious at best. And to top it off we have to transport this demo to where we are going to set it up and back. An absolutely massive crate was built that requires an entire truck. Because of these logistical challenges the demo was only used at Open World and they keynote at JavaOne.

Last year at Open World the demo was not working for the full length of the show. One of the biggest reasons is aligning 60 cameras to a single point is difficult at best and impossible with a precariously delicate mounting system. So software image stabilization was written which was done by Richard Bair on the floor under the demo.

If you read the previous article about Bullet Time, then you’d know a lighting track system was used to provide power. One of the benefits of using a lighting track system is that it handles power distribution. You provide the 120 volt AC input power to the track and it carries that power through copper wires built into the track. At any point where you want to have a light, you use a mount designed for the track system, which transfers the power through the mount to the light. A 48 volt DC power supply sends 20 amps through the wires designed for 120 volts AC. Each camera has a small voltage regulator to step down to the 5 volts DC required for a Raspberry Pi. The brilliance of this system is, it is easy to send power and transmit the shutter release of the cameras and transfer of the photos via WiFi. Unfortunately WiFi is unreliable at a conference, there are far too many devices jamming up the spectrum, so that required running individual Ethernet cables to each camera which is what we were trying to avoid by using the lighting track system. So we end up with a Ethernet harness strapped to the track.

Once we opened up the crate, and setup BulletTime, only one camera was not functioning. On the software side there are four parts:

 

  1. A tablet that the user interacts with providing a name and optional mobile number and a button to start the countdown to take the photo.
  2. The Java server receives countdown, sends out a UDP packet to the Raspberry Pi cameras to take a photo. The server also receives the photos and stitches them together to make the video.
  3. Python code running on the Raspberry Pi listens for a UDP packet to take a photo and know where to send it.
  4. The cloud software uploads the video to a YouTube channel.  And a text message with the link is sent to the user.

The overall system works like this:

  1. The user would input their name on the Oracle JavaScript Extension Toolkit (Oracle JET) web UI we built for this demo, which is running on a Microsoft Surface tablet.
  2. The user would then click a button on the Oracle JET web UI to start a 10-second countdown.
  3. The web UI would invoke a REST API on the Java server to start the countdown.
  4. After a 10-second delay, the Java server would send a multicast message to all the Raspberry Pi units at the same moment instructing them to take a picture.
  5. Each camera would take a picture and send the picture data back up to the server.
  6. The server would make any adjustments necessary to the picture (see below), and then using FFMPEG, the server would turn those 60 images into an MP4 movie.
  7. The server would respond to the Oracle JET web UI's REST request with a link to the completed movie.
  8. The Oracle JET web UI would display the movie.

In general, this system worked really well. The primary challenge that we encountered was getting all 60 cameras to focus on exactly the same point in space. If the cameras were not precisely focused on the same point, then it would seem like the "virtual" camera (the resulting movie) would jump all over the place. One camera might be pointed a little higher, the next a little lower, the next a little left, and the next rotated a little. This would create a disturbing "bouncy" effect in the movie.

We took two approaches to solve this. First, each Raspberry Pi camera was mounted with a series of adjustable parts, such that we could manually visit each Raspberry Pi and adjust the yaw, pitch, and roll of each camera. We would place a tripod with a pyramid target mounted to it in the center of the camera helix as a focal point, and using a hand-held HDMI monitor we visited each camera to manually adjust the cameras as best we could to line them all up on the pyramid target. Even so, this was only a rough adjustment and the resulting videos were still very bouncy.

The next approach was a software-based approach to adjusting the translation (pitch and yaw) and rotation (roll) of the camera images. We created a JavaFX app to help configure each camera with settings for how much translation and rotation was necessary to perfectly line up each camera on the same exact target point. Within the app, we would take a picture from the camera. We would then click the target location, and the software would know how much it had to adjust the x and y axis for that point to end up in the dead center of each image. Likewise, we would rotate the image to line it up relative to a "horizon" line that was superimposed on the image. We had to visit each of the 60 cameras to perform both the physical and virtual configuration.

Then at runtime, the server would query the cameras to get their adjustments. Then, when images were received from the cameras (see step 6 above), we used the Java 2D API to transform those images according to the translation and rotation values previously configured. We also had to crop the images, so we adjusted each Raspberry Pi camera to take the highest resolution image possible, and then we cropped it to 1920x1080 for a resealing hi-def movie.

If we were to build Bullet Time version 2.0 we’d make a few changes, such as powering the Raspberry Pi using PoE, replace the lighting track with a stronger less flexible rolled aluminum square tube in eight sections rather than four, and upgrade the camera module with a better lens. But overall this is a fun project with a great user experience.

 

Pages