Esecuzione di un’API di app cellular a livello locale con Docker e Postman

Nello sviluppo di applicazioni mobili, un’API ben definita è cruciale per consentire una comunicazione senza soluzione di continuità tra il front-end cellular e i servizi di backend. L’esecuzione di questa API a livello locale può migliorare significativamente il flusso di lavoro di sviluppo, consentendo agli sviluppatori di testare e eseguire il debug delle loro applicazioni senza distribuirle su un server remoto. In questo articolo, esploreremo come eseguire una API di app cellular a livello locale utilizzando Docker e come testarla in modo efficace con Postman.

Perché usare Docker?

Docker Fornisce un ambiente leggero per l’esecuzione di applicazioni in contenitori, garantendo coerenza attraverso lo sviluppo, i take a look at e gli ambienti di produzione. Utilizzando Docker, gli sviluppatori possono isolare le dipendenze, gestire le versioni e semplificare il processo di distribuzione.

Impostazione del progetto

Prima di iniziare, assicurati di avere Docker e Postino installato sulla macchina.

1. Crea un’API semplice con node.js ed categorical

Creiamo una semplice API RESTful usando Node.js ed Categorical. Implementeremo endpoint per un’app cellular che gestisce un elenco di attività.

Passaggio 1: struttura del progetto

Crea una nuova listing per il tuo progetto:

mkdir mobile-app-api
cd mobile-app-api
mkdir src

All’interno della listing SRC, creare i seguenti file:

Passaggio 2: definire l’API

pacchetto.json:

{
  "title": "mobile-app-api",
  "model": "1.0.0",
  "description": "A easy API for managing duties",
  "major": "server.js",
  "scripts": {
    "begin": "node server.js"
  },
  "dependencies": {
    "categorical": "^4.17.3"
  }
}

server.js:

const categorical = require('categorical');
const app = categorical();
const port = 3000;

app.use(categorical.json());

let duties = (
  { id: 1, title: 'Activity One', accomplished: false },
  { id: 2, title: 'Activity Two', accomplished: false },
);

// Get all duties
app.get('/api/duties', (req, res) => {
  res.json(duties);
});

// Create a brand new activity
app.put up('/api/duties', (req, res) => {
  const newTask = {
    id: duties.size + 1,
    title: req.physique.title,
    accomplished: false,
  };
  duties.push(newTask);
  res.standing(201).json(newTask);
});

// Begin the server
app.pay attention(port, () => {
  console.log(`API operating at http://localhost:${port}`);
});

Passaggio 3: crea un file Docker

Nella listing root, crea un file denominato Dockerfile:

# Use the official Node.js picture
FROM node:18

# Set the working listing
WORKDIR /usr/src/app

# Copy bundle.json and set up dependencies
COPY src/bundle*.json ./
RUN npm set up

# Copy the remainder of the applying recordsdata
COPY src/ .

# Expose the API port
EXPOSE 3000

# Begin the applying
CMD ("npm", "begin")

Passaggio 4: crea un file di compositore Docker

Per semplificare l’esecuzione dell’API, creare a docker-compose.yml File nella listing principale:

model: '3.8'
providers:
  api:
    construct: .
    ports:
      - "3000:3000"

2. Costruire e gestire l’API con Docker

Per creare ed eseguire la tua API, esegui i seguenti comandi nel tuo terminale:

# Construct the Docker picture
docker-compose construct

# Run the Docker container
docker-compose up

Dovresti vedere l’output che indica che l’API è in esecuzione:

API operating at http://localhost:3000

3. Testare l’API con Postman

Ora che la tua API è in esecuzione localmente, puoi testarla usando Postman.

Passaggio 1: Open Postman

Avvia Postman e crea una nuova richiesta.

Passaggio 2: testare l’endpoint

1. Imposta il tipo di richiesta su “Get”.
2. Immettere l’URL: http: // localhost: 3000/api/compiti.
3. Fai clic su “Invia”. Dovresti vedere l’elenco dei compiti restituiti in formato JSON.

Passaggio 3: testare l’endpoint put up

1. Imposta il tipo di richiesta su “Posta”.
2. Immettere l’URL: http: // localhost: 3000/api/compiti.
3. Nella scheda Physique, selezionare “RAW“ e imposta il formato su JSON.
4. Immettere il seguente JSON per creare un nuovo compito:

   {
     "title": "Activity Three"
   }

5. Fai clic su “Invia”. Dovresti vedere l’attività appena creata nella risposta.

4. Visualizzazione dell’architettura API

Ecco un semplice diagramma che rappresenta l’architettura della nostra API:

                ┌─────────────────────┐
                │     Cell App      │
                └──────────▲──────────┘
                           │
                ┌──────────┴──────────┐
                │   Postman Shopper     │
                └──────────▲──────────┘
                           │
                 ┌─────────┴───────────┐
                 │    Docker Container   │
                 │  (Node.js + Categorical) │
                 └─────────▲───────────┘
                           │
                  ┌────────┴────────┐
                  │      API        │
                  └─────────────────┘

Conclusione

L’esecuzione di un’API di app cellular a livello locale utilizzando Docker consente agli sviluppatori di creare un ambiente di sviluppo coerente e isolato. Utilizzando per la containerizzazione e il postino per i take a look at, è possibile creare, eseguire e eseguire il debug in modo efficiente la tua API, portando a un’esperienza di sviluppo più fluida. Questa configurazione accelera lo sviluppo e garantisce che l’applicazione si comporti in modo coerente in vari ambienti.

Passi successivi

• Esplorare Docker Networking per collegare più servizi.
• Implementare un database (advert es. MongoDB o PostgreSQL) per l’archiviazione persistente.
• Integrano strumenti di documentazione API come Swagger per una migliore gestione dell’API.
• Prendi in considerazione la distribuzione dell’API in un servizio cloud una volta pronto per la produzione.

Ora dovresti essere in grado di semplificare il flusso di lavoro di sviluppo delle applicazioni mobili, assicurando che la tua API sia robusta e affidabile.