How to use Azure SDK with Unsupported Programming Languages? – Ruby

require 'faraday'
require 'json'

# Azure API endpoint
url = "https://management.azure.com/subscriptions/{subscription_id}/resourceGroups/{resource_group_name}/providers/Microsoft.Storage/storageAccounts/{storage_account_name}?api-version=2019-06-01"

# Azure token for authorization
token = "your_oauth_token"

# Create Faraday connection
conn = Faraday.new(url) do |f|
  f.request :json
  f.response :logger
  f.adapter Faraday.default_adapter
end

# Send a PUT request to create a new storage account
response = conn.put do |req|
  req.headers['Authorization'] = "Bearer #{token}"
  req.headers['Content-Type'] = 'application/json'
  req.body = {
    location: 'eastus',
    sku: { name: 'Standard_LRS' },
    kind: 'StorageV2',
    properties: {}
  }.to_json
end

puts "Response: #{response.status}, Body: #{response.body}"

# Create a storage account using Azure CLI
resource_group = "myResourceGroup"
storage_account = "mystorageaccount"
location = "eastus"

system("az storage account create --name #{storage_account} --resource-group #{resource_group} --location #{location} --sku Standard_LRS")

gem install azure_mgmt_resources
gem install azure-storage-blob

require 'azure_mgmt_resources'
require 'azure/storage/blob'

# Example: List resource groups
client = Azure::Resources::Profiles::Latest::Mgmt::Client.new
client.resource_groups.list.each do |group|
  puts group.name
end

🛠️ How Javonet Helps?

Javonet bridges the gap between different programming languages by allowing you to call methods, instantiate objects, and interact with classes from a different language—directly from your codebase. This means you can easily use the Azure SDK for Python in Ruby, or other unsupported languages without creating extra service layers or switching programming environments.

</> Code Example: Using Azure SDK in Ruby via Javonet

Here’s a practical example showing how Javonet can be used to access Azure SDK for Python from Ruby to create a resource groups in Azure.

First, we are going to analyze what we are going to cook. We will need an environment, then install all necessary tools. Next, we need to decide what we are going to do (in my example, creating a Resource Group in Azure as a simple demo of possibilities) and then figure out how to do it. We will use the Azure SDK for Python, so we should understand how it works.

!!! In my example, I totally skip the Azure authentication part. This can be done in various ways, depending on your needs. Here, the simplest way is to use the CLI—only for demo purposes. If you are using it in an application, consider using Managed Identity 😃

# install Azure CLI
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

Microsoft Learn: Install Azure CLI on Linux

# auth into Azure with web browser az login

So to do it in Python with Azure SDK for Python we will need 2 modules from Azure SDK: azure-identity to authenticate and azure-mgmt-resource to create Resource Group.

# import modules (after installing them with pip)
from azure.identity import DefaultAzureCredential
from azure.mgmt.resource import ResourceManagementClient

# authenticate using the default Azure credentials
credential = DefaultAzureCredential()

# set you sub id
subscription_id = "your-subscription-id"

# create instance of ResourceManagementClient
resource_client = ResourceManagementClient(credential, subscription_id)

# create Resource Group
resource_client.resource_groups.create_or_update(
        'resourcegroupname123',  # Resource group name
        {'location': 'northeurope'} # Location
)

• Azure SDK for Python: DefaultAzureCredential Class
• Azure SDK for Python: ResourceManagementClient Class
• Microsoft Learn: Use the Azure libraries to create a resource group
• Azure SDK for Python: create or update a resource group
• Azure SDK for Python: ResourceGroup Class

Remember to always check docs and what you are using 😃 in these example DefaultAzureCredential() takes no arguments and ResourceManagementClient() needs 2 arguments.

Next resource_groups.create_or_update() form ResourceManagementClient need 2 arguments. First name which is string and then parameters as dictionary in which we have to provide location of our Resource Group.

And that is it, you can now simply create RG with Python – Let’s do it in Ruby!

0. Prerequisites

Since we are working with Javonet, Azure, and Python, we need to take a few things into account (for this example, I have used GitHub Codespaces as my environment):

• Open fresh new GitHub Codespaces
• Install Azure CLI and log into Azure
• Install Ruby
• Install Python (watch out for a lot of pythons in your enviroment)
• Install necessary Python Modules for you Python
• Install Javonet to Ruby (command down there)
• Get your free trial key (3 mins of work) form Javonet.com
• For quick starter guides you can also visit our Getting Started for Ruby

And lets do it!

1. Install Javonet
   First, you need to install Javonet in your Ruby environment using the following command

   gem install javonet-ruby-sdk

2. Python
   Install necessary Python Modules:
   

   # sometime it is tricky to install modules in correct python, if you have problems with those modules try which -a python/python3/python38 etc commands to find correct one and install you modules there using full path to it
   # you can verify it with pip list command
   which python
   
   # in my case this Python
   /home/codespace/.python/current/bin/python -m pip install azure-identity
   /home/codespace/.python/current/bin/python -m pip install azure-mgmt-resource

3. Initialize Javonet and Load Python
   After installation, initialize Javonet and load the required Python environmentDon’t be intimidated by this complex syntax; it’s our Javonet. After understanding the concept and learning a few commands, it becomes very easy.

   require 'javonet-ruby-sdk'
   
   # use activate only once in your app (javonet.com for free trial)
   Javonet.activate("your-license-key")
   
   # create called runtime context
   called_runtime = Javonet.in_memory.python
   
   # load library
   called_runtime.load_library("your-path")
   #called_runtime.load_library(".")
   
   # set up variables
   subscription_id = "yor-subscription-id"
   
   # now load those modules using Javonet
   azure_identity = called_runtime.get_type("azure.identity.DefaultAzureCredential").execute
   azure_mgmt_resource = called_runtime.get_type("azure.mgmt.resource.ResourceManagementClient").execute
   
   # execute DefaultAzureCredential & ResourceManagementClient
   credential = azure_identity.create_instance().execute
   ResourceManagementClient_type = azure_mgmt_resource.create_instance(credential, subscription_id).execute
   
   # now is the tricky part. Do you remember that our python method 'create_or_update' takes 2 arguments? - name and dictionary. For name it is easy job but for dictioary we can do it in a bunch of ways. We need {'location': 'northeurope'}.
   
   # we can do it with some other Python builtins methods like split, zip and dict :)
   zip = called_runtime.get_type("builtins").invoke_instance_method("zip", ["location"], ["northeurope"]).execute
   dict = called_runtime.get_type("builtins").invoke_instance_method("dict",zip).execute
   prints = called_runtime.get_type("builtins").invoke_instance_method("print", dict).execute.get_value
   
   # and our final is Python {'location': 'northeurope'} in Ruby "dict" variable
   

   • https://www.javonet.com/
   • https://www.javonet.com/guides/v2/
4. Create Resource Group in Azure Subscription
   

   # now just simply get it all together and we are done :)
   
   Resource Group created! create_rg = ResourceManagementClient_type.get_instance_field("resource_groups").invoke_instance_method("create_or_update", "resourcegroupname123", dict).execute

5. Problems
In my example i ran into python problem:

/usr/lib/python3.8/importlib/__init__.py:127 in '__init__#import_module'
<frozen importlib._bootstrap>:1014 in '<frozen importlib#_gcd_import'
<frozen importlib._bootstrap>:991 in '<frozen importlib#_find_and_load'
<frozen importlib._bootstrap>:961 in '<frozen importlib#_find_and_load_unlocked'
<frozen importlib._bootstrap>:219 in '<frozen importlib#_call_with_frames_removed'
<frozen importlib._bootstrap>:1014 in '<frozen importlib#_gcd_import'
<frozen importlib._bootstrap>:991 in '<frozen importlib#_find_and_load'
<frozen importlib._bootstrap>:973 in '<frozen importlib#_find_and_load_unlocked'
: Exception No module named 'azure' (Exception)

in that case we installed our python modules in wrong python interpreter/version 😃

which -a python

# it given me some more Python installed in my env.
/home/codespace/.python/current/bin/python
/usr/local/python/current/bin/python
/opt/conda/bin/python

which -a python3

# even more pythons!
/home/codespace/.python/current/bin/python3
/usr/local/python/current/bin/python3
/opt/conda/bin/python3
/usr/bin/python3
/bin/python3

# our error give us a hint in the first line
line /usr/lib/python3.8/importlib/__init__.py:127 in '__init__#import_module'

# so lets install modules there 
/usr/bin/python3 -m pip install azure-identity
/usr/bin/python3 -m pip install azure-mgmt-resource

# and now our code works! RG created! - check it in your env or try to print it with python IN RUBY with Javonet!

In this example, we load the Azure SDK for Python, instantiate an Azure Management client, and created Resource Group — all from Ruby code, thanks to Javonet. The Ruby application now has full access to Azure services through Python libraries, with no need to change the development language.

You can also use Javonet to many other usecases like PyJokes in Ruby as simple as this 😁

/usr/bin/python3 -m pip install pyjokes

joke = called_runtime.get_type('pyjokes.get_joke').execute
joke_type = joke.create_instance().execute
result = joke_type.get_value
puts "pyjokes: " + result

# pyjokes: What does pyjokes have in common with Adobe Flash? It gets updated all the time, but never gets any better.

🌟 Benefits of Using Javonet

• Time Savings: Javonet eliminates the need to create custom API layers for unsupported languages, reducing the time spent on developing integrations.
• Performance: Since Javonet executes code directly in memory, it offers performance comparable to native SDK use.
• Cross-Platform: Javonet works across Windows, Linux, and Mac, providing flexibility for multi-platform deployments.
• Code Reusability: Developers can reuse existing Python codebases in different programming environments, making the process more efficient and consistent.

✅ Conclusion

In the rapidly evolving world of cloud computing, the ability to integrate across different technologies is crucial. Now Javonet enables developers working in languages without native Azure SDK support to fully utilize Azure’s cloud services. By using Javonet, developers can maintain their preferred programming languages while still leveraging the power of Azure SDK, streamlining their workflows and improving productivity.

This cross-language compatibility allows for faster development cycles and more flexible architecture choices, making Javonet a key tool for modern, cloud-based application development.

📚 More Resources and Steps

Learn More About Javonet and Azure SDK:

• Official Javonet Guides
• Azure SDK for Python Overview: Azure SDK for Python
• How to Use Azure SDK in Python: Azure SDK for Python

By following these resources, you can deepen your understanding of how to integrate Azure SDK with unsupported programming languages using Javonet and expand your capabilities in cloud application development.