EC2 JGroups Discovery

Question

Per il mio progetto attuale, abbiamo deciso di implementare la nostra applicazione su Elastic Computing Cloud di Amazon su alcune scatole Linux. Utilizziamo JGroups per le comunicazioni di gruppo e avevamo bisogno di un meccanismo di scoperta affidabile che non richiedesse la preconfigurazione di ogni applicazione con gli indirizzi degli altri membri del cluster (che è necessario con TCPPING, e 'ordina' del necessario con TCPGOSSIP). Dal momento che non possiamo usare UDP multicast, questo esclude la scoperta multicast dalle nostre opzioni.

Abbiamo esaminato l'utilizzo del protocollo S3 Ping, ma dopo aver letto che c'erano alcuni problemi di affidabilità con esso, abbiamo deciso di eseguire il nostro protocollo per realizzare questa scoperta.

Mi piacerebbe avere un feedback sul protocollo semplice che abbiamo scritto e su come potrebbe comparare a S3 Ping. L'unica limitazione che attualmente ha è che dipende dall'SDK AWS per Java.

public class EC2Ping extends Discovery { 

    private static final Logger log = LoggerFactory.getLogger(EC2Ping.class); 

    public static final short EC2_PING_PROTOCOL_ID = 1001; 
    private static final int DEFAULT_JGROUPS_PORT = 7800; 

    static { 
     ClassConfigurator.addProtocol(EC2_PING_PROTOCOL_ID, EC2Ping.class); 
    } 

    /** The JGroups port number */ 
    private int port = DEFAULT_JGROUPS_PORT; 

    /** The EC2 client */ 
    private AmazonEC2Client client; 

    /** The EC2 instance filters */ 
    private List<Filter> filters; 

    public EC2Ping(EC2Ping src) { 
     this.client = src.client; 
     this.port = src.port; 
    } 

    public EC2Ping() { 
     // Default constructor 
    } 

    @Required 
    public void setClient(AmazonEC2Client client) { 
     this.client = client; 
    } 

    public void setFilters(List<Filter> filters) { 
     this.filters = filters; 
    } 

    public void setPort(int port) { 
     this.port = port; 
    } 

    public int getPort() { 
     return port; 
    } 

    @Override 
    public Collection<PhysicalAddress> fetchClusterMembers(String cluster_name) { 
     List<PhysicalAddress> addresses = new ArrayList<PhysicalAddress>(); 
     DescribeInstancesRequest request = new DescribeInstancesRequest(); 
     if (filters != null) { 
      request.setFilters(filters); 
     } 
     DescribeInstancesResult result = client.describeInstances(request); 
     for (Reservation res : result.getReservations()) { 
      for (Instance instance : res.getInstances()) { 
       String ipAddr = instance.getPrivateIpAddress(); 
       IpAddress addr; 
       try { 
        addr = new IpAddress(ipAddr, port); 
        addresses.add(addr); 
       } catch (UnknownHostException uhe) { 
        log.error("Unable to resolve cluster member address [" + ipAddr + "]"); 
       } 
      } 
     } 
     return addresses; 
    } 

    @Override 
    public boolean isDynamic() { 
     return true; 
    } 

    @Override 
    public boolean sendDiscoveryRequestsInParallel() { 
     return true; 
    } 
} 

posso includere la mia configurazione stack di protocollo, se necessario, ma è molto simile a UDP, tranne che invece di ricerca Multicast, utilizza il nostro protocollo EC2Ping.

Le mie domande principali sono i seguenti:

1. Fa presente una soluzione più affidabile rispetto alla S3 Ping?
2. La dipendenza dall'SDK AWS di AWS nega l'utilità di questa soluzione? (in termini di contributo a JGroups)

Qualsiasi commento sarebbe molto apprezzato. Grazie

Answer 1

Si consiglia di dare un'occhiata a JGroups AWS Project su GitHub. Utilizza le API AWS per creare cluster utilizzando i tag EC2. Supporta anche i profili di istanza, quindi puoi estrarre la chiave di accesso e la chiave segreta dal tuo file di configurazione.