# Monday, December 7, 2020

Episode 638

Emily Cooper on the ISTI STEM Challenge

The Illinois Science & Technology Institute (ISTI) organizes a STEM Challenge that allows high school students to work on real-world problems with industry mentors.

Emily Cooper talks about this program, its goals, and the organization.

Monday, December 7, 2020 9:58:00 AM (GMT Standard Time, UTC+00:00)
# Sunday, December 6, 2020

12/6
Today I am grateful for a warm home on cold days.

12/5
Today I am grateful to my building's maintenance staff which fixed a bunch of things in my condo yesterday.

12/4
Today I am grateful for a visit from my son Nick.

12/3
Today I am grateful for online shopping

12/2
Today I am grateful for my son's new job.

12/1
Today I am grateful for new tires on my car.

11/30
Today I am grateful to get my bicycle's gears repaired.

11/29
Today I am grateful for a Spartan trifecta yesterday: Michigan State victories in football, basketball, and ice hockey!

11/28
Today I am grateful to those who express appreciation.

11/27
Today I am grateful to celebrate virtual Thanksgiving with family yesterday.

11/26
Today I am grateful to receive phone calls from people I care about.

11/25
Today I am grateful to successfully complete work on a project on which we have been working for months.

11/24
Today I am grateful to awaken to a gently falling snow.

11/23
Today I am grateful for movies and TV on-demand.

11/22
Today I am grateful for unseasonably warm late November Chicago weather.

11/21
Today I am grateful for dinner at The Publican with Tim last night.

11/20
Today I am grateful for my new (to me) Herman Miller Aeron chair.

11/19
Today I am grateful for a negative COVID-19 test.

11/18
Today I am grateful for a hot bath.

11/17
Today I am grateful that American Express quickly replaced my lost card.

11/16
Today I am grateful for my new AirPods.

11/15
Today I am grateful for
-a chance to explore the Natchez Trace yesterday
-an 8-day vacation with visits to Springfield, St. Louis, Memphis, and Nashville.


11/14
Today I am grateful to sit around a bonfire last night with Gaines and Mary.

11/13
Today I am grateful for:
-3 great days in Memphis
-live music last night at Printer's Alley in Nashville
-a bike ride yesterday around Richmond Creek

11/12
Today I am grateful for:
-my first visit to Mississippi
-a visit to the National Civil Rights Museum in Memphis yesterday

11/11
Today I am grateful for a bike ride along the Shelby Farms Greenline Trail in Memphis yesterday.

11/10
Today I am grateful for
-My first-ever visit to Arkansas
-Seeing live music last night on Beale Street
-Meeting Glenn Campbell's son and telling him how much I enjoyed his father's music.

11/9
Today I am grateful for:
-Brunch yesterday with Jeffrey and his family yesterday
-The hospitality and generosity of Kevin and Darlene this weekend.

11/8
Today I am grateful for the millions of Americans who voted against dishonesty, hate, and racism.

11/7
Today I am grateful for my new bike helmet.

11/6
Today I am grateful that John has returned with his puns to save us all.

11/5
Today I am grateful to attend non-work meetings yesterday with my co-workers as part of our annual OneWeek event.

11/4
Today I am grateful to learn a lot about web security yesterday.

11/3
Today I am grateful for the opportunity to vote.

11/2
Today I am grateful for my new bicycle phone mount.

Sunday, December 6, 2020 11:01:20 AM (GMT Standard Time, UTC+00:00)
# Saturday, December 5, 2020

A few years ago, I sat in a cafe in Bergen on the west coast of Norway, sipping a coffee and enjoying a small pastry. It was sweet and satisfying by itself; but I enjoyed it enough to order another; and then, another.

The stories within Neil Gaiman's Norse Mythology are like this. Each story is short and easily consumable (about 10-25 pages) and stands on its own; but together, they weave an epic of the gods of Scandinavia.

We hear the adventures of Odin, Thor, Loki, Balder, and the gods of Asgard, along with the giants, dwarves, creatures, and sentient rocks and plants that inhabit their universe. We hear of shape-shifting and battles, and treachery, and love. We learn about the families of the gods and their births and their deaths.

Gaiman has inserted pagan gods into his books in the past (American Gods and Anansi Boys) and even written entire books around Thor, Loki, and Odin (Odd and the Frost Giants), but those books extended the legends of the deities, while this book pulls from the original source material - the oral stories recounting the adventures of these immortals, from the beginning of the world to Ragnarok - the final battle of the gods.

He does so with a voice that suggests these tales are told around a campfire at night.

Some of these stories were long familiar to me from the reading of my youth and some of them I had not heard. But all seemed fresh as told by Gaiman.

We have always known that Neil Gaiman knows how to tell a story. But with Norse Mythology, he proves that he can tell someone else's story.

Saturday, December 5, 2020 5:00:17 PM (GMT Standard Time, UTC+00:00)
# Wednesday, December 2, 2020

Recently, I have been working with MinIO – a container-based object storage service. I’ve recorded much of what I’ve learned. The links below will get you up to speed if you want to learn about this technology.

Blog Posts

Getting Started with MinIO Server

Creating and using a MinIO Gateway for Azure

Using the MinIO Java SDK

Managing MinIO with the Amazon S3 SDK

Videos

Creating a MinIO Server

Creating a MinIO Agent for Azure Blob Storage

Using the MinIO Java Client SDK

Accessing MinIO with the AWS S3 SDK

Wednesday, December 2, 2020 9:15:00 AM (GMT Standard Time, UTC+00:00)
# Tuesday, December 1, 2020

Intro

In my last article, I showed how to manage buckets and objects in MinIO using the MinIO Java SDK.

However, MinIO has the advantage that one can also access it using the Amazon S3 Java API. This is helpful if you are migrating from S3 (a comparable object store hosted by Amazon Web Services) to MinIO.

The code below assumes that the following values are declared and initialized appropriately:

private String endPoint;  // The MinIO endpoint (e.g., "http://127.0.0.1:9000") 
private String accessKey; // The MinIO Access Key 
private String secretKey; // The MinIO Secret Key 
private String bucketName; // A MinIO bucket in which to store objects (e.g., "mybucket") 
private String localFileFolder; // A local folder on your file system to upload/download files to/from MinIO (e.g., "c:\files\")
  

In order to use the S3 SDK, your app must have a reference to it. In a Maven project, this is done by adding the following to the <dependencies> section of the project's POM.XML:

<dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-s3</artifactId>
    <version>1.11.858</version>
</dependency>
  

AmazonS3 Object

In your code, the first thing you will need is an AmazonS3 object, which has methods for managing your MinIO objects.

Here is the code for creating this object.

public static AmazonS3 getAmazonS3Client(String accessKey, String secretKey, String endPoint) { 
    ClientConfiguration clientConfig = new ClientConfiguration(); 
    clientConfig.setProtocol(Protocol.HTTP); 
    AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey); 
    AmazonS3 s3client = AmazonS3ClientBuilder 
            .standard() 
            .withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration(endPoint, Regions.US_EAST_1.name())) 
            .withPathStyleAccessEnabled(true) 
            .withClientConfiguration(clientConfig) 
             .withCredentials(new AWSStaticCredentialsProvider(credentials)) 
            .build();

    return s3client; 
}
  

Once you have an AmazonS3 object, you can use it to manage MinIO objects.

Uploading a File

For example, here is code to upload a file to a MinIO bucket:

public void UploadWithS3Client(String fileName) throws IOException { 
     AmazonS3 s3Client = getAmazonS3Client(accessKey, secretKey, endPoint); 
    String fileToUpload = localFileFolder + fileName; 
     try { 
        File file = new File(fileToUpload); 
        PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, fileName, file); 
        s3Client.putObject(putObjectRequest); 
    } catch (AmazonServiceException ase) { 
        System.out.println("Error Message:    " + ase.getMessage());

    } catch (AmazonClientException ace) { 
        System.out.println("Error Message: " + ace.getMessage()); 
    } 
}
  

List Objects

and code to get a list all the objects in a bucket

public List<String> ListS3Objects() { 
     List<String> blobList = new ArrayList<String>(); 
    System.out.format("Objects in S3 bucket %s:\n", bucketName); 
    AmazonS3 s3Client = getAmazonS3Client(accessKey, secretKey, endPoint); 
     ListObjectsV2Result result = s3Client.listObjectsV2(bucketName); 
    List<S3ObjectSummary> blobs = result.getObjectSummaries(); 
    for (S3ObjectSummary blob : blobs) { 
        blobList.add(blob.getKey()); 
        System.out.println("* " + blob.getKey()); 
    } 
    return blobList; 
 }
  

Download a File

and to download one of those objects to your local file system:

public void DownloadFromMinIOWithS3Client(String objectName) { 
    System.out.format("Downloading %s from S3 bucket %s...\n", objectName, bucketName); 
    AmazonS3 s3Client = getAmazonS3Client(accessKey, secretKey, endPoint); 
    try { 
        S3Object o = s3Client.getObject(bucketName, objectName); 
        S3ObjectInputStream s3is = o.getObjectContent(); 
        String downloadedFile = localFileFolder + "D_" + objectName; 
        FileOutputStream fos = new FileOutputStream(new File(downloadedFile)); 
        byte[] read_buf = new byte[1024]; 
        int read_len = 0; 
        while ((read_len = s3is.read(read_buf)) > 0) { 
            fos.write(read_buf, 0, read_len); 
        } 
        s3is.close(); 
        fos.close(); 
    } catch (AmazonServiceException e) { 
        System.err.println(e.getErrorMessage()); 
        System.exit(1); 
    } catch (FileNotFoundException e) { 
        System.err.println(e.getMessage()); 
         System.exit(1); 
    } catch (IOException e) { 
        System.err.println(e.getMessage()); 
        System.exit(1); 
        } 
    }
  

As you can see, once you have a reference to the object, the rest is just Java IO code.

Print File Contents

Finally, here is code to print the contents of a text object stored in MinIO. Again, it is simple Java IO once you have a reference to the object.

    public void PrintObjectContents(String objectName) throws IOException {
        AmazonS3 s3Client = getAmazonS3Client(accessKey, secretKey, endPoint);
        GetObjectRequest rangeObjectRequest = new GetObjectRequest(bucketName, objectName);
        S3Object objectPortion = s3Client.getObject(rangeObjectRequest);
        System.out.println("Printing bytes retrieved:");
        displayTextInputStream(objectPortion.getObjectContent());
    }

    private static void displayTextInputStream(InputStream input) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(input));
        while (true) {
            String line = reader.readLine();
            if (line == null)
                break;

            System.out.println("    " + line);
        }
        System.out.println();
    }
  

Conclusion

Here is the full code that you can find at https://github.com/DavidGiard/MinIO_Java_Demo:

package com.gcast.gcastminio.services;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.ClientConfiguration;
import com.amazonaws.Protocol;
import com.amazonaws.auth.AWSCredentials;
import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.client.builder.AwsClientBuilder;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.GetObjectRequest;
import com.amazonaws.services.s3.model.ListObjectsV2Result;
import com.amazonaws.services.s3.model.PutObjectRequest;
import com.amazonaws.services.s3.model.S3Object;
import com.amazonaws.services.s3.model.S3ObjectInputStream;
import com.amazonaws.services.s3.model.S3ObjectSummary;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class S3Service {

    // The following are set in application.properties
    @Value("${minio.endPoint}")
    private String endPoint;
    @Value("${minio.accessKey}")
    private String accessKey;
    @Value("${minio.secretKey}")
    private String secretKey;
    @Value("${minio.bucketName}")
    private String bucketName;
    @Value("${localFileFolder}")
    private String localFileFolder;

    public void UploadWithS3Client(String fileName) throws IOException {
        AmazonS3 s3Client = getAmazonS3Client(accessKey, secretKey, endPoint);
        String fileToUpload = localFileFolder + fileName;
        try {
            File file = new File(fileToUpload);

            PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, fileName, file);
            s3Client.putObject(putObjectRequest);
        } catch (AmazonServiceException ase) {
            System.out.println("Error Message:    " + ase.getMessage());

        } catch (AmazonClientException ace) {
            System.out.println("Error Message: " + ace.getMessage());
        }
    }

    public List<String> ListS3Objects() {
        List<String> blobList = new ArrayList<String>();
        System.out.format("Objects in S3 bucket %s:\n", bucketName);
        AmazonS3 s3Client = getAmazonS3Client(accessKey, secretKey, endPoint);
        ListObjectsV2Result result = s3Client.listObjectsV2(bucketName);
        List<S3ObjectSummary> blobs = result.getObjectSummaries();
        for (S3ObjectSummary blob : blobs) {
            blobList.add(blob.getKey());
            System.out.println("* " + blob.getKey());
        }
        return blobList;
    }

    public void PrintObjectContents(String objectName) throws IOException {
        AmazonS3 s3Client = getAmazonS3Client(accessKey, secretKey, endPoint);
        GetObjectRequest rangeObjectRequest = new GetObjectRequest(bucketName, objectName);
        S3Object objectPortion = s3Client.getObject(rangeObjectRequest);
        System.out.println("Printing bytes retrieved:");
        displayTextInputStream(objectPortion.getObjectContent());
    }

    private static void displayTextInputStream(InputStream input) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(input));
        while (true) {
            String line = reader.readLine();
            if (line == null)
                break;

            System.out.println("    " + line);
        }
        System.out.println();
    }

	public void DownloadFromMinIOWithS3Client(String objectName) {
		System.out.format("Downloading %s from S3 bucket %s...\n", objectName, bucketName);
		AmazonS3 s3Client = getAmazonS3Client(accessKey, secretKey, endPoint);
		try {
			S3Object o = s3Client.getObject(bucketName, objectName);
			S3ObjectInputStream s3is = o.getObjectContent();
			String downloadedFile = localFileFolder + "D_" + objectName;
			FileOutputStream fos = new FileOutputStream(new File(downloadedFile));
			byte[] read_buf = new byte[1024];
			int read_len = 0;
			while ((read_len = s3is.read(read_buf)) > 0) {
				fos.write(read_buf, 0, read_len);
			}
			s3is.close();
			fos.close();
		} catch (AmazonServiceException e) {
			System.err.println(e.getErrorMessage());
			System.exit(1);
		} catch (FileNotFoundException e) {
			System.err.println(e.getMessage());
			System.exit(1);
		} catch (IOException e) {
			System.err.println(e.getMessage());
			System.exit(1);
			}
		}


    public static AmazonS3 getAmazonS3Client(String accessKey, String secretKey, String endPoint) {
        ClientConfiguration clientConfig = new ClientConfiguration();
        clientConfig.setProtocol(Protocol.HTTP);
        AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
        AmazonS3 s3client = AmazonS3ClientBuilder
                .standard()
                .withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration(endPoint, Regions.US_EAST_1.name()))
                .withPathStyleAccessEnabled(true)
                .withClientConfiguration(clientConfig)
                .withCredentials(new AWSStaticCredentialsProvider(credentials))
                .build();

        return s3client;
	}
}
  

In this article, you learned how to use the Amazon S3 Java SDK to manage objects in MinIO.

Tuesday, December 1, 2020 7:23:00 AM (GMT Standard Time, UTC+00:00)
# Monday, November 30, 2020

Episode 637

Gaines Kergosien on ADHD

Gaines Kergosien discusses ways to identify and cope with the challenges of ADHD.

Links:

https://add.org/
http://blog.kergosien.net/
https://speakerdeck.com/gaines/succeeding-with-adhd

Monday, November 30, 2020 7:31:00 AM (GMT Standard Time, UTC+00:00)
# Saturday, November 28, 2020

Each of the novels in Madeleine L'Engle's Time Quintet contains allusions to religion, often including angelic and demonic beings that battle in a struggle of good versus evil; but, Many Waters" - her fourth book in this series (third chronologically) - takes it a step farther. Here, L'Engle explicitly introduces angels and fallen angels and even the Old Testament prophet Noah and his family.

Throughout the series, Dennys and Sandy have been the forgotten siblings of the remarkable Murry family. These twins mostly stood in the background while older sister Meg and Charles Wallace went on adventures to save the universe.

But, in Many Waters, the twins take the stage. After playing with one of their father's laboratory experiments, they find themselves thrust backward in time to encounter Noah and his family prior to the Great Flood. The boys find themselves in the middle of a struggle between Noah's family and others. Angels, fallen angels, and magical creatures play a part in the battle. The story is complicated when Noah receives instructions from God to begin building his ark in preparation for the coming flood.

It was fun to see some minor characters emphasized; and it was fun to read an adventure story with familiar characters. Madeleine L'Engle has made me care about the Murry family.

Saturday, November 28, 2020 9:57:00 AM (GMT Standard Time, UTC+00:00)
# Wednesday, November 25, 2020

Intro

In previous articles, I showed how to configure a MinIO Server and a MinIO Gateway for Azure.

In those articles, I demonstrated how to manage objects using the MinIO user interface.

In this article, I will show how to use the MinIO Java API to manage MinIO objects.

In order to use the MinIO API, you will need to set a dependency in your project. In a Maven project, this is done by adding the following to the <dependencies> section of the project's POM.XML:

<dependency>
  <groupId>io.minio</groupId>
  <artifactId>minio</artifactId>
  <version>7.1.2</version>
</dependency>
  

The code below assumes that the following values are declared and initialized appropriately:

private String endPoint;        // The MinIO endpoint (e.g., "http://127.0.0.1:9000")
private String accessKey;       // The MinIO Access Key
private String secretKey;       // The MinIO Secret Key
private String bucketName;    // A MinIO bucket in which to store objects (e.g., "mybucket")
private String localFileFolder; // A local folder on your file system to upload/download files to/from MinIO (e.g., "c:\files\")

You will also need to import namespaces from the subnamespaces of min.io. Your IDE will help you identify variables that require these namespaces.   

The MinIOClient object

In your code, you will need a MinioClient object to work with MinIO. A builder helps with this.

MinioClient minioClient = MinioClient.builder().endpoint(endPoint).credentials(accessKey, secretKey).build();
  

Buckets

Below is the code to check if a bucket already exists and create it if it does not

boolean bucketExists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build()); 
if (!bucketExists) { 
    minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build()); 
}
  

Notice the arguments passed to bucketExists. These arguments are creased with a builder (BucketExistsArgs.builder().bucket(bucketName).build()). The arguments for makeBucket use a similar pattern. We will see this pattern in a lot of MinioClient methods.

Uploading a File

Here is the code to upload a file into a MinIO bucket.

String fileName = "file1.txt"; // This file must exist in the local file folder 
String fileToUpload = localFileFolder + fileName; 
UploadObjectArgs args = UploadObjectArgs.builder().bucket(bucketName).object(fileName).filename(fileToUpload).build(); 
minioClient.uploadObject(args);
  

Downloading a File

Here is the code to download an object to a file on your local drive:

String fileName = "file1.txt"; // This file must exist in the MinIO bucket 
String downloadedFile = localFileFolder + "D_" + fileName; 
DownloadObjectArgs args = DownloadObjectArgs.builder().bucket(bucketName).object(fileName) 
        .filename(downloadedFile).build(); 
minioClient.downloadObject(args);
  

Conclusion

The full listing of a class to read and write to MinIO is shown in Listing 1

Listing 1:

package com.gcast.gcastminio.services;

import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import io.minio.BucketExistsArgs;
import io.minio.DownloadObjectArgs;
import io.minio.MakeBucketArgs;
import io.minio.MinioClient;
import io.minio.UploadObjectArgs;
import io.minio.errors.MinioException;

@Service
public class MinIOService {

    // The following are set in application.properties
    @Value("${minio.endPoint}")
    private String endPoint;
    @Value("${minio.accessKey}")
    private String accessKey;
    @Value("${minio.secretKey}")
    private String secretKey;
    @Value("${minio.bucketName}")
    private String bucketName;
    @Value("${localFileFolder}")
    private String localFileFolder;

    public void WriteToMinIO(String fileName)
            throws InvalidKeyException, IllegalArgumentException, NoSuchAlgorithmException, IOException {
        try {
            MinioClient minioClient = MinioClient.builder().endpoint(endPoint)
                    .credentials(accessKey, secretKey).build();

            boolean bucketExists = minioClient.bucketExists(BucketExistsArgs.builder().bucket(bucketName).build());
            if (!bucketExists) {
                minioClient.makeBucket(MakeBucketArgs.builder().bucket(bucketName).build());
            }

            String fileToUpload = localFileFolder + fileName;
            UploadObjectArgs args = UploadObjectArgs.builder().bucket(bucketName).object(fileName)
                    .filename(fileToUpload).build();
            minioClient.uploadObject(args);

            System.out.println(fileToUpload + " successfully uploaded to:");
            System.out.println("   container: " + bucketName);
            System.out.println("   blob: " + fileName);
            System.out.println();
        } catch (MinioException e) {
            System.out.println("Error occurred: " + e);
        }
    }

    public void ReadFromMinIO(String fileName)
            throws InvalidKeyException, IllegalArgumentException, NoSuchAlgorithmException, IOException {
        try {
            MinioClient minioClient = MinioClient.builder().endpoint(endPoint)
                    .credentials(accessKey, secretKey).build();
            String downloadedFile = localFileFolder + "D_" + fileName;
            DownloadObjectArgs args = DownloadObjectArgs.builder().bucket(bucketName).object(fileName)
                    .filename(downloadedFile).build();
            minioClient.downloadObject(args);

            System.out.println("Downloaded file to ");
            System.out.println(" " + downloadedFile);
            System.out.println();
        } catch (MinioException e) {
            System.out.println("Error occurred: " + e);
        }
    }
    
}
  

You can download and run  this code from https://github.com/DavidGiard/MinIO_Java_Demo

The code is the same whether you are running a MinIO Server or MinIO Gateway.

In this article, you learned how to use the MinIO Java SDK to read and write objects stored in MinIO.

Database | Java | MinIO
Wednesday, November 25, 2020 9:56:00 AM (GMT Standard Time, UTC+00:00)
# Tuesday, November 24, 2020

What is MinIO?


MinIO is an object storage system, similar to Amazon S3 or Azure Blob storage. It is built on top of Docker containers, which makes it easy to scale.

In a previous article, I showed you how to create and use a MinIO Server.

In this article, I will show how to create and use a MinIO Gateway for Azure Blob Storage.

MinIO Gateway

A MinIO Server stores files and objects. By contrast, a MinIO points to some other storage repository where the files are stored. However, it allows you to interact with those files as if they were stored in MinIO.

Prerequisites

Before you begin, you will need to install Docker Desktop, which you can download for either Windows or Mac.

You will also need an Azure Storage Account. This article explains how to create an Azure Storage Account.

Azure Blob Storage

You will need two pieces of information from your Azure Storage Account: the name of the storage account and the access key.

In the Azure Portal (https://portal.azure.com), you can find the storage account name at the top of the Resource page, as shown in Fig. 1.

mga01-StorageAccountName
Fig. 1

You can find the key on the "Access Keys" blade, as shown in Fig. 2.

mga02-StorageAccountKeys
Fig. 2

Note that there are two keys. Either one will work. Click the [Show Keys] button to view the keys and allow copying to your clipboard.

Creating a MinIO Gateway

A MinIO Gateway for Azure is created with the following command:

docker run -p 9000:9000 --name azure-s3 -e "MINIO_ACCESS_KEY=azurestorageaccountname" -e "MINIO_SECRET_KEY=azurestorageaccountkey" minio/minio gateway azure

where

azurestorageaccountname is the name of the Azure storage account and azurestorageaccountkey is an account key from that same storage account.

You can now log into the MinIO Gateway by opening a browser and navigating to http://127.0.0.1:9000/.

When prompted for your login credentials (Fig. 3), enter the storage account name in the "Access key" field and enter the storage account key in the "Secret Key" field.

mga03-Login
Fig. 3

After a successful login, the MinIO Gateway user interface will display, as shown in Fig. 4.

mga04-MinIO

Fig. 4

Note that this looks exactly like the MinIO Server user interface, described in this article.

In fact, you can create buckets and manage files in a MinIO Gateway exactly as you would in a MinIO server. The only difference is that the objects you manipulate are stored in the corresponding Azure Blob storage, rather than in MinIO. Each bucket is mapped to a Blob Storage container and each file is mapped to a blob.

Conclusion

In this article, you learned how to create a MinIO Gateway for Azure.

Tuesday, November 24, 2020 9:31:00 AM (GMT Standard Time, UTC+00:00)
# Monday, November 23, 2020

Episode 636

Omkar Naik on Microsoft Cloud for Health Care

Microsoft Cloud Solution Architect Omkar Naik describes what Microsoft is doing for health care solutions with Azure, Dynamics, Office 365, and other tools and services.

Links:
http://aka.ms/smarterhealth
http://aka.ms/microsoftcloudforhealthcare
http://aka.ms/azure

Monday, November 23, 2020 9:15:00 AM (GMT Standard Time, UTC+00:00)