Geautomatiseerde overdracht en archivering van mediabestanden met MASV en Backblaze

by Ankit Verma | 14 december 2021

Als u regelmatig met video werkt, bent u ongetwijfeld gewend om grote mediabestanden naar klanten/teamgenoten te sturen en daarna een back-up van uw mediabestanden te maken op een of andere opslagunit. De kans is groot dat wanneer u uw mediabestanden overdraagt en archiveert, dit een proces in twee stappen is. Vandaag wil ik laten zien hoe u mediabestanden automatisch kunt overbrengen en archiveren in één enkel proces, met als voorbeeld een combinatie van MASV Portals en Backblaze.

Het belangrijkste voordeel van het combineren van deze twee acties, afgezien van snelheid/efficiëntie, is ervoor te zorgen dat er nooit een bestand wordt vergeten tijdens het back-upproces. Iedereen heeft wel eens een map geopend met bestanden met de naam file01.mp4, file02.mp, file01changed.mp4. Een snel back-upproces dat ongelooflijk snel ingewikkeld wordt. Met een automatisch en eenvoudig back-upproces kunt u echter elk bestand scheiden op basis van uploaddatum en bestandsgrootte. Dit kan en zal u tijd en moeite besparen om uit te zoeken welke versie van een bestand de belangrijke is. 

Vandaag de dag kan de integratie van MASV met cloud providers zoals Backblaze eenvoudig worden gerealiseerd op onze web app met een paar klikken. Dit artikel gaat echter een stapje verder door te laten zien hoe je deze stappen kunt implementeren met MASV's Cloud Connect API. Hiermee kunt u het proces automatiseren dat verder gaat dan een enkele cloudverbinding en een automatiseringskrachtcentrale creëren die meerdere MASV Portalen naar meerdere cloud providers/opslag emmers. We zullen python3 gebruiken als scripttaal om te demonstreren hoe gemakkelijk dit kan worden bereikt.

Media overzetten en archiveren met MASV + Backblaze

mediabestanden overbrengen en archiveren met masv en backblaze

Zoals gezegd, gaan we vandaag MASV en Backblaze gebruiken. Ons doel is om een eenvoudig python3 script te maken dat beide diensten zal verbinden en kan laten zien hoe eenvoudig MASV's Cloud Connect technologie werkt. Beide technologieën bieden een aantal mogelijkheden. Hier zijn enkele hoogtepunten van wat we vandaag gebruiken.

MASV:

  • Ultrasnelle overdracht van grote bestanden.
  • Automatische overdracht van volledige directories.
  • Cloud Connect: integratie met externe cloud buckets om de bestanden automatisch te verplaatsen naar waar u ze nodig hebt.

BackBlaze:

  • Goedkope onbeperkte lange termijn opslag.
  • Ongelooflijk eenvoudige cloudback-up.
  • Werkstroom vriendelijk.
  • Ondersteunt twee-factor authenticatie.

Wij gebruiken Backblaze als onze Cloud Connect provider voor de integratie met MASV. Al deze stappen kunnen worden veralgemeend om met elke provider te werken, zoals uiteengezet in onze documentatie.

Heb je geen MASV account?

Krijg 100 GB wanneer u zich aanmeldt.

Veronderstellingen over de workflow

Wij gaan uit van het volgende:

  • Een code-editor zoals Visual studio code.
  • Python3 geïnstalleerd en de mogelijkheid om scripts te draaien.
  • Een MASV rekening.
  • Backblaze B2-account met API-sleutel.

Voordat we beginnen, willen we er zeker van zijn dat u een Backblaze B2-sleutel hebt. Volg de gids op https://www.backblaze.com/b2/docs/application_keys.html

Opstellen van vereisten

Begin met het maken van een bestand genaamd backblaze.py dit is het script waar alle code in geschreven zal worden.

Dit script vereist de mogelijkheid om http requests te versturen en om dat te doen gaan we gebruik maken van de verzoeken bibliotheek.

In uw terminal, installeer de verzoeken pakket.

$ pip3 installatieverzoeken

Authenticatie met MASV

Voor onze authenticatie gaan we onze gebruikersnaam/wachtwoord gebruiken. Dit kan ook met een gebruikers token maar om het eenvoudig te houden gebruiken we vandaag username/password. We raden ten zeerste aan om een API sleutel te gebruiken. Een API sleutel kan gemakkelijk worden veranderd in het geval dat de sleutel wordt gelekt. Terwijl gebruikersauthenticatie toegang kan geven tot uw volledige accountdashboard.


//python
importeer verzoeken

api_uri = 'https://api.massive.app/v1'
api_auth_route = '/auth'

auth_request = {
    "email": "[email protected]",
    "password": "yourpassword"
}

r = requests.post(
    api_uri + api_auth_route,
    json=auth_request
)
auth_response = r.json()
auth_token = auth_response['token']
team_id = auth_response['teams'][0]['id']

print("Gegrepen authenticatie token")

Er is een beetje boiler plaat hier om ons op gang te krijgen. Lijn #1 laat ons de verzoeken bibliotheek. Terwijl lijn #3 ons de api uri laat definiëren. Dit is belangrijk omdat het ons toelaat om gemakkelijk de standaard route te wijzigen in geval van eventuele toekomstige domeinwijzigingen. Gevolgd door de exacte route voor de authenticatie.

We vullen onze gebruikersnaam en wachtwoord in voor onze auth aanvraag. Dit is de gebruikersnaam en het wachtwoord dat u gebruikt om toegang te krijgen tot het MASV dashboard. Tot slot gaan we over tot het daadwerkelijk doen van de aanvraag. Met string concatenation combineren we de api_uri en api_auth_route om de volledige url te maken https://api.massive.app/v1/auth en onze auth_request variabele als json.

We voelen ons goed vandaag, dus we gaan er gewoon van uit dat de aanvraag is doorgekomen en beginnen variabelen op te halen (voor een overzicht van alle geretourneerde variabelen, ga naar onze documentatie.)

De variabelen die we nodig hebben zijn:

  • auth_token: gebruikt om onze verzoeken te authenticeren
  • team_id: het team waaraan wij onze verzoeken en cloud-verbinding koppelen

Een geauthenticeerd verzoek verzenden

Geweldig! We hebben nu ons gebruikers token, maar hoe gaan we het eigenlijk gebruiken? In het geval van MASV's api, gaan we ons token toevoegen aan onze request headers. Een simpel stukje json zal ons op weg helpen zodat we het kunnen gaan gebruiken in het script

//python
team_id = auth_response['teams'][0]['id']
...

request_headers = {
    "Content-Type": "application/json",
    "X-User-Token": "auth_token",
}

Automatiseringen opzetten met MASV Portalen

Een beetje een omweg voordat we echt aan de slag gaan met Backblaze. Ons doel hier is om automatisch mediabestanden naar Backblaze over te brengen en te archiveren. We kunnen dat doen door gebruik te maken van de Portaal functie in MASV. U kunt een portaal zien als een emmer waarin al uw bestanden worden opgeslagen in MASV.

Een portal kan worden gemaakt met de GUI of met een snel script. In dit geval gaan we een snel script gebruiken:

//python
    "X-User-Token": auth_token,
}
...

# Verkrijg portaal id
api_portals_route = '/teams/{}/portals'.format(team_id)

# Dit verzoek zal mislukken als het subdomein
# niet is gewijzigd. Haal het commentaar weg uit de regel met het subdomein
# en vervang de `masvbackblaze` door uw eigen
# om het verzoek te laten slagen.
portal_request = {
    "name": "masvtobackblaze",
    "message": "Gegevens verzenden naar backblaze",
    "subdomein": "masvbackblaze",
    "ontvangers": [
        "[email protected]"
    ],
    "access_code": "uw_toegangs_code",
    "heeft_toegangs_code": True,
    "download_password": "uw_download_wachtwoord",
    "heeft_download_password": True,
}

r = requests.post(
    api_uri + api_portals_route,
    headers=request_headers,
    json=portal_request
)

# We zijn iets aan het maken
# dus we moeten evalueren of het
# echt werkt
indien r.status_code !.= 201:
    print(r.status_code)
    print(r.json()["bericht"])
    exit()

portal = r.json()
portal_id = portal["id"]
print("Aangemaakt portaal: {}".format(portal_id))

Er is een hoop uit te pakken hier. We beginnen met het krijgen van onze api_portals_route deze route interageert met eventuele Portal verzoeken die we moeten doen. Python bevat de mooie .format() functie die ons in staat stelt om de team_id die we eerder in de uri hebben gezet.

Voor het eigenlijke antwoord moet een ketelplaat worden gemaakt. We stellen een aantal redelijke standaardwaarden in. De subdomein is een uniek veld en zal voor elke persoon uniek moeten zijn. 

Ons verzoek gebruikt nu ook ons authenticatie token met de regel headers=request_headers elke verzoekfunctie die authenticatie vereist, zal vanaf nu deze headers bevatten.

We willen de creatie verifiëren dus we controleren op de 422 foutmelding waar onze api mee zal reageren. Als het al bestaat, zal het de foutcode uitvoeren en afsluiten.

Let op: Voor volledige info over de portaal creatie bezoek onze documentatie.

Backblaze aansluiten

We zijn nu klaar om een Backblaze B2 verbinding te maken. Om dit te doen gaan we de eigenlijke cloud verbinding maken en deze koppelen aan de Portal die we in de vorige stap hebben gemaakt. Dit zal de overdracht en archivering van videobestanden die in MASV zijn geüpload naar Backblaze automatiseren.

//python
portal_id = r.json()["id"]
...

api_cloudconnect_route = '/teams/{}/cloud_connections'.format(team_id)
backblaze_connect_request = {
    "name": "backblazetomasv",
    "provider": "backblazeb2",
    "authorization": {
        "client_id": "0005bbxxxxxxxxxxxx",
        "client_secret": "K000xxxxxxxxxxx",
        "bestemming": "team-bucket",
    }
}

r=requests.post(
    api_uri + api_cloudconnect_route,
    headers=request_headers,
    json=backblaze_connect_request
)

print("Aangemaakte cloudverbinding {}".format(r.json()['id'])

# We zijn iets aan het creëren
# dus we moeten evalueren of het
# echt werkt
als r.status_code == 422:
    print(r.json()["message"])
    exit()

cloudconnect_id = r.json()['id']

Veel van deze code zou vertrouwd moeten aanvoelen. We beginnen met het maken van de cloudconnect route op onze api. Gevolgd door enkele parameters voor onze Backblaze verbinding. De naam veld moet worden aangepast aan de naamgevingsconventie die uw bedrijf hanteert.

Het authenticatieblok is vereist en wordt ingevuld met de gegevens die zijn gegenereerd in Backblaze API Sleutel.

//python
# Bevestig aan portaal

api_cloudconnect_attach_route = "/portals/{}".format(portal_id)

api_cloudconnect_request = portal_request
api_cloudconnect_request['active'] = True
api_cloudconnect_request['configure_cloud_connections'] = True
api_cloudconnect_request['cloud_connections'] = [{
    "id": cloudconnect_id,
    "actief": True,
    "target_action": "transfer".
}]

r=requests.put(
    api_uri + api_cloudconnect_attach_route,
    headers=request_headers,
    json=api_cloudconnect_request
)

print("Aangemaakte portaalverbinding")

Voer de code uit met een finale:

  $ python3 backblaze.py

Wat het volgende zal opleveren:

  Authenticatie token opgehaald
  Aangemaakt portaal: UW_PORTAAL_ID_HIER
  Aangemaakte cloudverbinding YOUR_CLOUD_CONNECTION_ID_HERE
  Aangemaakte portaalverbinding

Deze uitvoer bevestigt dat uw script met succes is uitgevoerd en dat u nu een portaal hebt aangemaakt en gekoppeld aan een Backblaze B2-bak. 

Voor een beetje extra validatie dat het portaal is verbonden, kunnen we navigeren naar het Cloud Connect dashboard. Onder de Cloud Connection-pagina kunt u zien dat het script een verbinding heeft gemaakt met de naam backblazetomasv. Met een groene ok status betekent dat alles goed is om te gaan.

De volgende stap op uw lijst is de fysieke overdracht en archivering van deze mediabestanden. Een snelle drag-and-drop naar MASV en u kunt tekenen voor de nacht, wetende dat de gegevens zullen worden verzonden en veilig worden opgeslagen.

Uw manager (de ontvanger die u hierboven hebt ingesteld) ontvangt een e-mail wanneer zij het bestand kunnen downloaden. Backblaze zal uw bestand(en) klaar hebben staan in een van zijn emmers.

backblaze emmer details

Wilt u weten hoe u bestanden kunt overzetten door ze gewoon naar een map op uw bureaublad te verplaatsen? Bekijk onze lopende blogreeks over het implementeren van TransferAgent in Docker. Of als u meer wilt zien van wat u met onze API kunt doen, bekijk dan onze Dev Docs hier.

Klaar om MASV te proberen?

Meld je aan en krijg 100 GB aan overschrijvingen van ons.