> ## Content Index
> Fetch the complete content index at: https://www.azurebrasil.cloud/llms.txt
> Use this file to discover other available public pages before exploring further.

# BlobFuse - Azure Blob Storage como Filesystem no Linux
- URL: https://www.azurebrasil.cloud/blog/blobfuse-azure-blob-storage-como-filesystem-no-linux/
- Published: 2024-05-24T18:17:07.000Z
- Updated: 2024-05-31T15:11:52.000Z
- Author: Wiluey Sousa
- Tags: azure-storage, powershell, azure-linux

Fala comunidade!

Nada melhor do que tirar a poeira da mobília com um post bacana sobre Infra Azure, concordam?

Bom, vamos lá!

Antes de mais nada, a primeira coisa a ser entendida antes de entrarmos no técnico é: **Já ouviram falar sobre Blobfuse?**

**Blobfuse** é um driver utilizado em sistemas operacionais baseados em Linux (diferentes distros) que simula um filesystem que aponta direto para um blob storage do Azure, ou seja, através do driver, o Blobfuse simula um diretório virtual.

O Blobfuse dá suporte à instalação nas seguintes distros:

- Ubuntu: 16\. 4, 18\. 4 e 20\. 4
- RHELversions: 7.5, 7.8, 8.0, 8.1, 8.2
- CentOS: 7.0, 8.0
- Debian: 9.0, 10.0
- SUSE: 15
- OracleLinux 8.1

Mas Will, não seria mais fácil apontar diretamente para um **File Share** dentro do meu Blob Storage?

Depende!

Por dois motivos:

- File Share tem o limite de **5TB**, parece muito, mas tratando-se de armazenamento, acreditem, não é!
- Exige o uso do protoclo **SMB 3.0** para ser usado nas distros listadas acima.

Então avalie bem a sua necessidade.

Agora que já entendemos o Blobfuse, vamos à prática?

Primeiramente vamos logar no portal do Azure ([www.portal.azure.com](http://www.portal.azure.com/?ref=azurebrasil.cloud)) e abrir o **Cloud Shell** para executarmos comandos na linguagem Powershell (imagem abaixo).

![](https://res.cloudinary.com/practicaldev/image/fetch/s--m_0wEA4O--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/4qv2oe89wlbukzq9is3c.jpg)

Obs: Se preferir, pode fazer isso direto pela console do Powershell ISE também, basta apenas logar na sua subscription.

Daqui pra frente nós vamos usar scripts powershell para a criação da Sorage Account, CLI para a criação da VM e o Packer para o deploy da imagem.

Logado no Powershell, execute os comandos abaixo:  
**Listar as suas Subscriptions (caso tenha mais de uma)**

```
Get-AzSubscription
```

**Selecionar o ID da sua Subscription e insira-o como parâmetro**

```
Set-AzContext -Subscription "xxxxx-xxxxx-xxxxxxxxxxxxxxxx"
```

**Crie seu Resource Group (RG)**

```
$resourceGroup = "BlobFuseWiluey" (Aqui crie o nome que quiser)
$location = "eastus"
New-AzResourceGroup -Name $resourceGroup -Location $location
```

**Crie a Storage Account**

```
$storageAccount = New-AzStorageAccount -ResourceGroupName $resourceGroup -Name "blobfusestoragewill" -SkuName Standard_LRS -Location $location
$ctx = $storageAccount.Context
```

**Crie o Container Storage**

```
$containerName = "blobfuse-will-azure"
New-AzStorageContainer -Name $containerName -Context $ctx -Permission blob
```

Aqui finalizamos a primeira etapa, já temos nossa Storage Account criada.

Agora vamos brincar um pouco com DevOps e gerar a imagem da nossa máquina virtual com o Packer.

Não conhece o **Packer**?

O Packer é um dos produtos da HashiCorp (como o Terraform), criado para gerar e gerenciar imagens de forma automatizada.

  
Ele também é capaz de construir a imagem de sua aplicação, banco de dados ou sistema operacional utilizando os seus mesmos **playbooks** e scripts inseridos no Userdata.

Uma vantagem do Packer é possibilidade de criar imagens multiplataforma com o mesmo código, uma vez que ele é compatível com AWS, Microsoft Azure, Google Cloud, VMWare, Docker, Digital Ocean, dentre outras.

  
O Packer não substitui os seus **configurations managers**, mas faz uso deles para provisionar as imagens criadas.

Agora vamos lá!

Altere o seu Cloud Shell agora para usar o Bash, onde vamos executar scripts CLI (imagem abaixo).

![](https://res.cloudinary.com/practicaldev/image/fetch/s--lmYSCBEi--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/wptvix1pcbjjkhd3pt5k.jpg)

Feito isso, vamos "setar" a **subscription** correta, não vamos provisionar o recurso no lugar errado, certo?

**Execute o comando abaixo para listar suas Subscriptions:**

```
az account show
```

**"Sete" a Subscription:**

```
az account set --subscription "xxxxxxx-xxxxxxxxx-xxxxxxxxxxxxxx"
```

Como não vamos criar uma VM para servir como nosso configuration Manager, vamos usar o módulo nativo do Azure.  
Porém para usar o módulo nativo, e necessário gerar uma role de acesso (RBAC) para gerar os códigos que serão usados no script para autenticação.

**Execute o comando abaixo e guarde os ID's gerados**

```
az ad sp create-for-rbac --query "{ client_id: appId, client_secret: password, tenant_id: tenant }"
```

**Com o comando abaixo você pega o ID da Subscription**

```
az account show --query "{ subscription_id: id }"
```

**Obs:** Não transfira, ceda ou mostre publicamente esse ID para NINGUÉM!

Basicamente os comandos acima lhe trarão os IDs dos parametros abaixo:

```
"client_id": "xxxxx-xxxxxxxx-xxxxxxxxxxxxxxx"
"client_secret": "xxxxx-xxxxxxxx-xxxxxxxxxxxxxxx"
"tenant_id": "xxxxx-xxxxxxxx-xxxxxxxxxxxxxxx"
"subscription_id": "xxxxx-xxxxxxxx-xxxxxxxxxxxxxxx"
```

Agora com os IDs em mãos, vá para o Cloud Shell (em modo BASH) e gere o JSON com as configuraçõe da nossa imagem.

O script com o JSON está no meu **GitHub**, pegue-o no link abaixo:

- [https://github.com/Wiluey/packer/blob/master/RedHat7.json](https://github.com/Wiluey/packer/blob/master/RedHat7.json?ref=azurebrasil.cloud)

Agora que possui o JSON, execute o comando o comando abaixo (no BASH):

```
vi RedHat7.json (um novo arquivo será criado)

Tecle "I"(insert) e cole o JSON dentro deste arquivo novo que foi aberto com o "vi"

Tecle ESC seguido de :wq (para salvar e sair)
```

Agora com o JSON criado, vamos chamado o módulo do PACKER para gerar a nossa imagem.

Execute o comando abaixo:

```
packer build RedHat7.json
```

Uma imagem parecida vai informar o status do Deploy:

![](https://res.cloudinary.com/practicaldev/image/fetch/s--Gjm_Ot4T--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/nl675lhi4nbgs6k15bpf.jpg)

O tempo de geração da imagem leva em torno de 10 a 12 minutos.

Quando o processo finalizar, teremos o output abaixo:

![](https://res.cloudinary.com/practicaldev/image/fetch/s--COcfMf27--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/75devrmptvnftn30y4j8.jpg)

E indo até o Resource Group, você verá o recurso provisionado:

![](https://res.cloudinary.com/practicaldev/image/fetch/s--baWPwJkN--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/a4c31qr8jx6wuytnjyq2.jpg)

![](https://res.cloudinary.com/practicaldev/image/fetch/s--Rr6X8Inv--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/bq9mmxkno3ytwp0m4zjo.jpg)

Repare que em "Data Disks" não há nenhuma LUN ou LVM montado. Isso foi proposital para que a minha imagem fosse a mais "limpa" possível.  
E o **Blobfuse vai fazer esse papel depois...**

Agora é o momento de criarmos nossa máquina virtual Linux Red Hat 7 a partir da nossa imagem.

No Cloud Shell (em modo BASH), execute o comando abaixo:

```
az vm create --resource-group BlobFuseWiluey --name WilueyVmLinux --image PackerImageBlobfuse --admin-username wiluey --admin-password "xxxxxx" (senha forte aqui)
```

Após o deploy da nova VM criada a partir da nossa imagem, teremos um output confirmando o IP Publico atribuído a ela (conforme imagem):

![](https://res.cloudinary.com/practicaldev/image/fetch/s--lBZpiEm5--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/ceg0khw1com6wxi1keci.jpg)

Agora vamos testar/validar o acesso à nossa máquina virtual, execute o comando:

- **ssh seuuser@seuippublico**

O output:

![](https://res.cloudinary.com/practicaldev/image/fetch/s--B7gU6Gg---/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/cyxprjzi81w4rtbpo5zg.jpg)

Sucesso!

Agora a etapa final, criar o Blobfuse e fazer o linux reconhecer nosso container como um filesystem.

A imagem abaixo comprova que nossa distro possui apenas os pontos de montagem padrão (o "barra").[](https://res.cloudinary.com/practicaldev/image/fetch/s--lBZpiEm5--/c%5Flimit%2Cf%5Fauto%2Cfl%5Fprogressive%2Cq%5Fauto%2Cw%5F880/https://dev-to-uploads.s3.amazonaws.com/i/ceg0khw1com6wxi1keci.jpg?ref=azurebrasil.cloud)

![](https://res.cloudinary.com/practicaldev/image/fetch/s--H9jq1PI---/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/vhwmapq7da0ys6ho0msm.jpg)

Logados no Linux, o primeiro passo é criar as variáveis de ambiente globais, utilizando o comando **export**:

```
export AZURE_STORAGE_ACCOUNT=nome_da_sua_storage_account
export AZURE_STORAGE_ACCESS_KEY=a_sua_chave_de_acesso
```

Não sabe onde encontra isso?  
Vem comigo!

Execute o comando abaixo:

```
az storage account keys list -g BlobFuseWiluey -n blobfusestoragewill
```

Obviamente alterando os parâmetros para os seus, onde **"-g"** é o nome do Resource Group e **"-n"** é o nome da Storage Account.

O output:

![](https://res.cloudinary.com/practicaldev/image/fetch/s--V591VRNq--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/rzqtz50k6tmgsp1fx7wu.jpg)

Na variável de ambiente, basta inserir o valor retornado em "value" da **Key1**.

Criadas as variáveis, agora vamos criar os diretórios que serão nossos binários.

Primeiramente eleve seus privilégios:

```
sudo su
```

Depois execute os comandos abaixo (inserindo o nome que quiser):

```
cd /home/wiluey
mkdir blobfuse-mount-will/
chown wiluey:wiluey blobfuse-mount-will/
```

Acima estamos autorizando o usuário a acessar nosso filesystem, afinal não podemos usar o **root** o tempo todo, até mesmo por questões de segurança.

Execute a instalação do Blobfuse:

```
rpm -Uvh https://packages.microsoft.com/config/rhel/7/packages-microsoft-prod.rpm
yum install blobfuse -y
```

Crie uma pasta temporária vazia:

```
mkdir /blobfuse-mount-will-tmp
```

Agora vamos fazer o "mount" do nosso diretório com o Blobfuse:

```
blobfuse /home/wiluey/blobfuse-mount-will --container-name=blobfuse-will-azure --tmp-path=/blobfuse-will-tmp
```

Vamos validar se o filesystem foi devidamente reconhecido pelo SO:

![](https://res.cloudinary.com/practicaldev/image/fetch/s--vgQluM8X--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/imhi7brhsga4wizjj90p.jpg)

Sucesso!

Vamos fazer o teste e copiar algum arquivo para nosso container storage, o mesmo deve aparecer no Linux, certo?

Existem diversas maneiras, mas pra ganharmos tempo, vou fazer o upload via Portal.

Fazendo uma primeira verificação, constatamos que o volume está vazio.

![](https://res.cloudinary.com/practicaldev/image/fetch/s--MRINeAMV--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/l6ma92jubet5yxqpi33r.jpg)

Navegue até seu Container Storage, selecione um arquivo qualquer da sua máquina e faça o upload do mesmo para o Azure conforme imagem abaixo:

![](https://res.cloudinary.com/practicaldev/image/fetch/s--gibYb-wc--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/flvddzdshrevhpelj9ow.jpg)

Arquivo encontra-se no container após o upload:

![](https://res.cloudinary.com/practicaldev/image/fetch/s--eo7eBym9--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/7uopqjthf482nufsihve.jpg)

Vamos ver se ele está na VM, dentro do nosso filesystem?

![](https://res.cloudinary.com/practicaldev/image/fetch/s--9OpQmFuR--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/6mw1ioxtkous3dl5thbf.jpg)

**Voilà!**

Tudo certo, nosso filesystem foi reconhecido com sucesso e está acessível!

Existem outras opções para uso de área temporária, como o **ramdisk**, que consiste em usar parte da sua memória RAM como se fosse um disco local, mas isso é assunto para um outro post, ainda tem muito assunto sobre Infra Azure para falarmos.

Agora um **ponto de atenção** super importante:  
Este foi apenas um laboratório que servirá de estudos e aprendizado aos leitores.  
E por ser um laboratório, diversas regras de segurança foram deixadas de lado, portanto se um dia houver a necessidade de criar uma arquitetura desta em ambiente produtivo, conte com um arquiteto experiente que conheça bem a **segurança** do Azure e as boas práticas para manter os dados da sua empresa seguros, não arrisque as práticas deste tutorial!

Ah, é importante saber que temos a versão 2 do BlobFuse. O **BlobFuse2** é um projeto de código aberto que usa a biblioteca de software livre do libfuse (fuse3) para se comunicar com o módulo de kernel do Linux FUSE. O BlobFuse2 implementa as operações do sistema de arquivos usando as APIs REST do Armazenamento do Microsoft Azure.

Mas isso é papo para outro post!

Acompanhem o blog para ficar por dentro do mundo Cloud Computing!

Grande abraço e até a próxima!