‹ Retour

Le terme "hostname" fait généralement référence au nom d'un ordinateur ou d'un dispositif sur un réseau. Voici comment obtenir ou définir le hostname dans différents langages de programmation :

Python

Pour obtenir le hostname en Python, vous pouvez utiliser le module socket :

import socket

hostname = socket.gethostname()
print("Hostname:", hostname)

Java

En Java, vous pouvez utiliser la classe InetAddress pour obtenir le hostname :

import java.net.InetAddress;
import java.net.UnknownHostException;

public class HostnameExample {
    public static void main(String[] args) {
        try {
            String hostname = InetAddress.getLocalHost().getHostName();
            System.out.println("Hostname: " + hostname);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

JavaScript (Node.js)

Pour obtenir le hostname en utilisant Node.js, vous pouvez utiliser le module os :

const os = require('os');

const hostname = os.hostname();
console.log("Hostname:", hostname);

C#

En C#, vous pouvez utiliser la classe Dns du namespace System.Net :

using System;
using System.Net;

class Program
{
    static void Main()
    {
        string hostname = Dns.GetHostName();
        Console.WriteLine("Hostname: " + hostname);
    }
}

Bash

En shell script sous Linux ou macOS, vous pouvez utiliser la commande hostname :

hostname

Ruby

Pour obtenir le hostname en Ruby, vous pouvez utiliser la bibliothèque Socket :

require 'socket'

hostname = Socket.gethostname
puts "Hostname: #{hostname}"

PHP

En PHP, vous pouvez utiliser la fonction gethostname() :

<?php
$hostname = gethostname();
echo "Hostname: " . $hostname;
?>

Go

En Go, vous pouvez utiliser le package os :

package main

import (
    "fmt"
    "os"
)

func main() {
    hostname, err := os.Hostname()
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println("Hostname:", hostname)
    }
}

Swift

En Swift, vous pouvez utiliser la classe ProcessInfo :

import Foundation

let hostname = ProcessInfo.processInfo.hostName
print("Hostname: \(hostname)")

Pour obtenir le hostname dans une application Spring Boot, vous pouvez utiliser la classe InetAddress de Java, tout comme dans une application Java standard. Voici comment vous pouvez intégrer cette fonctionnalité dans un contrôleur Spring Boot pour qu'elle soit accessible via une requête HTTP.

Spring Boot

Voici un exemple de code pour créer une application Spring Boot qui retourne le hostname lorsqu'on accède à un endpoint spécifique :

Étape 1 : Créez une nouvelle application Spring Boot

1. Créez un projet Spring Boot en utilisant Spring Initializr (https://start.spring.io) ou directement dans votre IDE préféré.
2. Ajoutez les dépendances nécessaires, comme spring-boot-starter-web.

Étape 2 : Créez un contrôleur pour retourner le hostname

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.net.InetAddress;
import java.net.UnknownHostException;

@RestController
public class HostnameController {

    @GetMapping("/hostname")
    public String getHostname() {
        try {
            String hostname = InetAddress.getLocalHost().getHostName();
            return "Hostname: " + hostname;
        } catch (UnknownHostException e) {
            e.printStackTrace();
            return "Hostname could not be determined";
        }
    }
}

Étape 3 : Lancez l'application Spring Boot

1. Créez le fichier Application.java pour lancer votre application Spring Boot :

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Assurez-vous que votre structure de projet ressemble à ceci :

src/main/java
└── com
    └── example
        └── demo
            ├── Application.java
            └── HostnameController.java

Étape 4 : Testez l'application

1. Démarrez votre application Spring Boot en exécutant la méthode main dans la classe Application.
2. Accédez à http://localhost:8080/hostname dans votre navigateur ou utilisez un outil comme curl ou Postman pour envoyer une requête GET à ce endpoint.

Cela devrait retourner le hostname de la machine sur laquelle l'application Spring Boot est en cours d'exécution. Voici un exemple de réponse possible :

Hostname: my-computer

Ce code montre comment intégrer la récupération du hostname dans une application Spring Boot et l'exposer via un endpoint REST.

 

 

 

Pour une configuration générale avec Docker et Traefik, vous pouvez suivre les étapes suivantes, en utilisant Docker Compose pour orchestrer les services. Cette configuration n'est pas spécifique à une application particulière.

Dockerfile

Assurez-vous que votre application a un fichier Dockerfile pour la construire en image Docker. Voici un exemple générique :

# Utiliser une image de base appropriée pour votre application
FROM appropriate/base-image

# Copier les fichiers de l'application dans le conteneur
COPY . /app

# Définir le répertoire de travail
WORKDIR /app

# Installer les dépendances (si nécessaire)
# RUN appropriate-package-manager install

# Exposer le port sur lequel l'application écoute
EXPOSE 8080

# Commande pour démarrer l'application
CMD ["appropriate-command", "to-start-your-app"]

Docker Compose

Créez un fichier docker-compose.yml pour définir et exécuter les services, y compris Traefik comme reverse proxy.

version: '3'

services:
  traefik:
    image: traefik:v2.5
    command:
      - "--api.insecure=true" # Active l'API et le tableau de bord de Traefik
      - "--providers.docker=true" # Utilise Docker comme fournisseur
      - "--entrypoints.web.address=:80" # Déclare l'entrée web sur le port 80
    ports:
      - "80:80" # Mappe le port 80 du conteneur au port 80 de l'hôte
      - "8080:8080" # Mappe le port 8080 du conteneur au port 8080 de l'hôte pour l'API Traefik
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock:ro" # Montre le socket Docker pour que Traefik puisse lire les labels
    networks:
      - web

  my-app:
    image: my-app-image # Remplacez par le nom de l'image de votre application
    container_name: my-app
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.my-app.rule=Host(`localhost`)" # Règle de routage de Traefik
      - "traefik.http.services.my-app.loadbalancer.server.port=8080" # Port interne sur lequel l'application écoute
    networks:
      - web

networks:
  web:
    external: true

Créez un réseau Docker

Créez un réseau Docker nommé web si ce n'est pas déjà fait :

docker network create web

Démarrez les services avec Docker Compose

Exécutez la commande suivante pour démarrer les services définis dans le fichier docker-compose.yml :

docker-compose up -d

Testez l'application

Accédez à l'application en ouvrant votre navigateur et en naviguant vers http://localhost. Vous pouvez également accéder au tableau de bord de Traefik à http://localhost:8080.

Résumé de la configuration

• Dockerfile : Décrit comment construire l'image Docker de votre application.
• docker-compose.yml : Définit les services Docker, y compris Traefik comme reverse proxy et votre application.
• Réseau Docker : Utilisé pour connecter Traefik et votre application.

Cette configuration vous permet de déployer une application générique avec Docker et de la rendre accessible via Traefik. Vous pouvez ajuster les configurations de Traefik et des labels Docker en fonction de vos besoins spécifiques.