Come eseguire l'immagine Docker di Aspose.CAD in Azure Function

Requisiti

Docker deve essere installato sul tuo sistema. Per informazioni su come installare Docker su Windows o Mac, consulta i collegamenti nella sezione “Vedi anche”.
IntelliJ IDEA.
Azure Toolkit per IntelliJ.
Postman.

Azure Function

In questo esempio, crei una semplice funzione di conversione che converte un file CAD e lo salva come immagine. L’applicazione può quindi essere costruita in Docker ed eseguita in Azure Function.

Creazione della Azure Function

Per creare il programma Azure Function, segui i passaggi di seguito:

Una volta installato Docker, assicurati che utilizzi contenitori Linux (predefinito). Se necessario, seleziona l’opzione Passa a contenitori Linux dal menu di Docker Desktops.
Crea un progetto Azure Function in IntelliJ IDEA.
Strumenti -> Azure -> Accedi e seleziona l’autenticazione OAuth 2.0.
Accedi nel browser.
Seleziona il nome dell’abbonamento.
Aggiungi supporto Docker.
Modifica il DockerFile come nella sezione Configurare un Dockerfile.

Aggiungi blocchi per il repository aspose.cad in pom.xml.

<repositories>
    <repository>
		<id>AsposeJavaAPI</id>
        <name>Aspose Java API</name>
        <url>https://releases.aspose.com/java/repo/</url>
    </repository>
</repositories>


<dependencies>
 <dependency>
    <groupId>com.aspose</groupId>
    <artifactId>aspose-cad</artifactId>
    <version>22.3</version>
    <scope>compile</scope>
  </dependency>
</dependencies>

Quando tutte le dipendenze necessarie sono aggiunte, scrivi un semplice programma che crea un’ellisse e la salva come immagine:

public class HttpTriggerFunction {
    /**
     * Questa funzione ascolta all'endpoint "/api/HttpExample". Due modi per attivarla utilizzando il comando "curl" in bash:
     * 1. curl -d "Corpo HTTP" {il tuo host}/api/HttpExample
     * 2. curl "{il tuo host}/api/HttpExample?name=HTTP%20Query"
     */
    @FunctionName("HttpExample")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET, HttpMethod.POST},
                authLevel = AuthorizationLevel.ANONYMOUS)
                HttpRequestMessage<Optional<String>> request,
            final ExecutionContext context) throws FileNotFoundException {
        context.getLogger().info("Il trigger HTTP Java ha elaborato una richiesta.");

        try{
            String body = request.getBody().get();
            InputStream targetStream = new ByteArrayInputStream(body.getBytes());

            CadImage image = (CadImage)Image.load(targetStream);
            {
                CadRasterizationOptions rasterizationOptions = new CadRasterizationOptions();
                rasterizationOptions.setPageWidth(1200);
                rasterizationOptions.setPageHeight(1200);

                ImageOptionsBase options = new PngOptions();
                options.setVectorRasterizationOptions(rasterizationOptions);

                ByteArrayOutputStream out = new ByteArrayOutputStream();

                image.save(out, options);

                return request.createResponseBuilder(HttpStatus.OK)
                        .header("Content-type", "image/png")
                        .header("Content-Disposition", "attachment;filename=filename.png")
                        .body(out.toByteArray()).build();
            }
        }
        catch (Exception e)
		{
            return request.createResponseBuilder(HttpStatus.BAD_REQUEST).body(e.getMessage()).build();
        }
    }
}

Configurazione di un Dockerfile

Il passo successivo è creare e configurare il Dockerfile nella cartella principale del progetto.

Nel Dockerfile, specifica:

FROM mcr.microsoft.com/azure-functions/java:3.0-java8-build AS installer-env

COPY . /src/java-function-app
RUN cd /src/java-function-app && \
    mkdir -p /home/site/wwwroot && \
    mvn clean package && \
    cd ./target/azure-functions/ && \
    cd $(ls -d */|head -n 1) && \
    cp -a . /home/site/wwwroot

FROM mcr.microsoft.com/azure-functions/java:3.0-java8-appservice

ENV AzureWebJobsScriptRoot=/home/site/wwwroot \
    AzureFunctionsJobHost__Logging__Console__IsEnabled=true

COPY --from=installer-env ["/home/site/wwwroot", "/home/site/wwwroot"]

Il sopra è un semplice Dockerfile, che contiene le seguenti istruzioni:

L’immagine SDK da utilizzare. Docker la scaricherà quando il build viene eseguito. La versione dell’SDK è specificata come tag.
La cartella di lavoro, che è specificata nella riga successiva.
Il comando per copiare tutto nel container, pubblicare l’applicazione e specificare il punto di ingresso.

Docker Hub

Accedi a Docker Hub
Crea un repository pubblico

Costruzione e esecuzione dell’applicazione in Docker

Ora l’applicazione può essere costruita ed eseguita in Docker. Apri il tuo prompt dei comandi preferito, cambia la directory nella cartella con l’applicazione (cartella in cui si trova il file di soluzione e il Dockerfile) e esegui il seguente comando:

Costruisci il comando dockerfile nella console

//esempio
docker build -t <nome utente>/<nome repository> .

docker build -t user/asposefunction .

La prima volta che esegui questo comando, potrebbe richiedere più tempo perché Docker deve scaricare le immagini necessarie. Dopo che il comando precedente è stato completato, esegui il seguente comando per inviare l’immagine a Docker Hub.
```
//esempio
docker push <nome utente>/<nome repository>:tagname

docker push user/aspose-cad-java:latest
```
Esegui il Dockerfile in IDE e dopo invia a Docker Hub.
Inserisci il nome dell’immagine, come nel repository di Docker Hub.
Attendi la fine.

Azure

Accedi ad Azure.
Scegli i servizi Azure.
Scegli Function App e crea una funzione.
Ripeti le impostazioni di base come nell’immagine seguente.
Clicca su ‘Rivedi + crea’ -> Crea.
Attendi il completamento del deployment.
Clicca sul pulsante ‘Vai alla risorsa’.
Ferma la funzione aspose-cad-docker-example.
Vai al menu centro di distribuzione e fai le impostazioni appropriate.
Salva le impostazioni
Copia l’URL del webhook dalle impostazioni del centro di distribuzione.
Vai a Docker Hub, seleziona il tuo repository e seleziona webhooks.
Incolla l’URL del ‘Webhook’ da Azure nell’URL del webhook di Docker Hub e imposta il nome.
Clicca sul pulsante Crea.
Torna alla panoramica della funzione Azure e avvia il contenitore.

Potrebbe richiedere alcuni minuti per avviare la funzione.

Esempio di esecuzione

Impostazioni di Postman.
Seleziona qualsiasi file DXF, DWG, DGN, DWF, DWFX, IFC, STL, DWT, IGES, PLT, CF2, OBJ, HPGL, IGS, PCL, FBX, PDF, file SVG.
Clicca sul pulsante invia.
Salva il risultato

Se la risposta è positiva, clicca su Salva su file e riceverai il file convertito in formato PNG.

Altri esempi

Per ulteriori campioni su come puoi utilizzare Aspose.CAD in Docker, consulta gli esempi.

Vedi anche

Come Eseguire gli Esempi Supporto Tecnico