All Products
Search
Document Center

Media upload

Last Updated: Jul 11, 2019

This topic describes how to use the Go server SDK to call server operations, for example, to obtain the upload URL and credential and register media asset information. To upload complete media files, you can use the client upload SDK together with the upload URL and credential.

Initialize a client

Initialize a client before using the SDK. For more information, see InitVodClient.

Obtain the video upload URL and credential

For more information about the request and response parameters, see CreateUploadVideo.

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
)

func MyCreateUploadVideo(client *vod.Client) (response *vod.CreateUploadVideoResponse, err error) {
    request := vod.CreateCreateUploadVideoRequest()

    request.Title = "Sample Video Title"
    request.Description = "Sample Description"
    request.FileName = "/opt/video/sample/video_file.mp4"
    //request.CateId = "-1"
    request.CoverURL = "http://img.alicdn.com/tps/TB1qnJ1PVXXXXXCXXXXXXXXXXXX-700-700.png"
    request.Tags = "tag1,tag2"

    request.AcceptFormat = "JSON"
    return client.CreateUploadVideo(request)
}


func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>") 
    if err ! = nil {
        panic(err)
    }

    response, err := MyCreateUploadVideo(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Printf("VideoId: %s\n UploadAddress: %s\n UploadAuth: %s",
        response.VideoId, response.UploadAddress, response.UploadAuth)
}

Refresh the video upload credential

For more information about the request and response parameters, see RefreshUploadVideo.

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
)

func MyRefreshUploadVideo(client *vod.Client) (response *vod.RefreshUploadVideoResponse, err error) {
    request := vod.CreateRefreshUploadVideoRequest()
    request.VideoId = "6657f89a86fa4f76a295ae95636e5aed"
    request.AcceptFormat = "JSON"

    return client.RefreshUploadVideo(request)
}

func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>")
    if err ! = nil {
        panic(err)
    }

    response, err := MyRefreshUploadVideo(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Printf("UploadAddress: %s\n UploadAuth: %s", response.UploadAddress, response.UploadAuth)
}

Obtain the image upload URL and credential

For more information about the request and response parameters, see CreateUploadImage.

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
)

func MyCreateUploadImage(client *vod.Client) (response *vod.CreateUploadImageResponse, err error) {
    request := vod.CreateCreateUploadImageRequest()

    request.ImageType = "cover"
    request.ImageExt = "jpg"
    request.Title = "Sample Image Title"
    //request.CateId = "-1"
    request.Tags = "tag1,tag2"

    request.AcceptFormat = "JSON"
    return client.CreateUploadImage(request)
}


func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>")
    if err ! = nil {
        panic(err)
    }

    response, err := MyCreateUploadImage(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Printf("ImageId: %s\n ImageURL: %s\n UploadAddress: %s\n UploadAuth: %s",
        response.ImageId, response.ImageURL, response.UploadAddress, response.UploadAuth)
}

Obtain the upload URL and credential for an attached media asset

For more information about the request and response parameters, see CreateUploadAttachedMedia.

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
)

func MyCreateUploadAttachedMedia(client *vod.Client) (response *vod.CreateUploadAttachedMediaResponse, err error) {
    request := vod.CreateCreateUploadAttachedMediaRequest()

    request.BusinessType = "watermark"
    request.MediaExt = "gif"
    request.Title = "Sample watermark Title"
    //request.CateId = "-1"
    request.Tags = "tag1,tag2"

    request.AcceptFormat = "JSON"
    return client.CreateUploadAttachedMedia(request)
}

func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>") 
    if err ! = nil {
        panic(err)
    }

    response, err := MyCreateUploadAttachedMedia(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Printf("MediaId: %s\n MediaURL: %s\n FileURL: %s\n UploadAddress: %s\n UploadAuth: %s",
        response.MediaId, response.MediaURL, response.FileURL, response.UploadAddress, response.UploadAuth)
}

Upload multiple videos based on mezzanine file URLs

For more information about the request and response parameters, see UploadMediaByURL.

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
    "encoding/json"
    "net/url"
    "strings"
)

func MyUploadMediaByURL(client *vod.Client) (response *vod.UploadMediaByURLResponse, err error) {
    request := vod.CreateUploadMediaByURLRequest()

    // Encodes mezzanine file URLs.
    sourceUrls := []string{"https://sample.oss-cn-shanghai.aliyuncs.com/vod_sample1.mp4",
        "https://sample.oss-cn-shanghai.aliyuncs.com/vod_sample2.flv"}
    uploadUrls := []string{}
    metadatas := []map[string]interface{}{}
    for _, surl := range sourceUrls {
        encodeUrl := url.QueryEscape(surl)
        uploadUrls = append(uploadUrls, encodeUrl)
        metadata := map[string]interface{}{"SourceURL": encodeUrl, "Title":"UploadMediaByURL Sample Title"}
        metadatas = append(metadatas, metadata)
    }

    // Specifies a list of mezzanine file URLs. Separate multiple URLs with a comma (,).
    request.UploadURLs = strings.Join(uploadUrls, ",")

    // (Optional) Specifies the metadata of the videos to be uploaded.
    jsonMetas, err := json.Marshal(metadatas)
    if err ! = nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    request.UploadMetadatas = string(jsonMetas)

    // (Optional) Sets the ID of the transcoding template group.
    //request.TemplateGroupId = "<TemplateGroupId>" 

    request.AcceptFormat = "JSON"
    return client.UploadMediaByURL(request)
}

func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>") 
    if err ! = nil {
        panic(err)
    }

    response, err := MyUploadMediaByURL(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    for _, job := range response.UploadJobs {
        fmt.Printf("%s: %s\n", job.JobId, job.SourceURL)
    }
}

Register media asset information

For more information about the request and response parameters, see RegisterMedia.

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
    "encoding/json"
)

func MyRegisterMedia(client *vod.Client) (response *vod.RegisterMediaResponse, err error) {
    request := vod.CreateRegisterMediaRequest()

    metadatas := []map[string]interface{}{}
    metadata1 := map[string]interface{}{"FileURL":"https://sample.oss-cn-shanghai.aliyuncs.com/vod_sample1.mp4",
        "Title":"RegisterMedia sample Title 1"}
    metadata2 := map[string]interface{}{"FileURL":"https://sample.oss-cn-shanghai.aliyuncs.com/vod_sample2.mp4",
        "Title":"RegisterMedia sample Title 2"}
    metadatas = append(metadatas, metadata1, metadata2)
    jsonMetas, err := json.Marshal(metadatas)
    if err ! = nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    request.RegisterMetadatas = string(jsonMetas)
    //request.TemplateGroupId = "<TemplateGroupId>" 

    request.AcceptFormat = "JSON"
    return client.RegisterMedia(request)
}

func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>")
    if err ! = nil {
        panic(err)
    }

    response, err := MyRegisterMedia(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Println(response.FailedFileURLs)
    fmt.Println(response.RegisteredMediaList)
}

Obtain the information about upload based on mezzanine file URLs

For more information about the request and response parameters, see GetURLUploadInfos.

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
    "strings"
)

func MyGetURLUploadInfos(client *vod.Client) (response *vod.GetURLUploadInfosResponse, err error) {
    request := vod.CreateGetURLUploadInfosRequest()

    // Encodes mezzanine file URLs.
    sourceUrls := []string{"https://sample.oss-cn-shanghai.aliyuncs.com/vod_sample1.mp4",
        "https://sample.oss-cn-shanghai.aliyuncs.com/vod_sample2.flv"}
    uploadUrls := []string{}
    for _, surl := range sourceUrls {
        encodeUrl := url.QueryEscape(surl)
        uploadUrls = append(uploadUrls, encodeUrl)
    }

    // Specifies a list of mezzanine file URLs. Separate multiple URLs with a comma (,).
    request.UploadURLs = strings.Join(uploadUrls, ",")

    // Specifies the IDs of upload jobs, alternatively.
    //request.JobIds = "jobId1,jobId2"

    request.AcceptFormat = "JSON"
    return client.GetURLUploadInfos(request)
}

func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>") 
    if err ! = nil {
        panic(err)
    }

    response, err := MyGetURLUploadInfos(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Println(response.NonExists)
    for _, uploadInfo := range response.URLUploadInfoList {
        fmt.Printf("%s: %s %s\n", uploadInfo.UploadURL, uploadInfo.Status, uploadInfo.MediaId)
    }
}