🥇We duiken in FreePBX en integreren het met Bitrix24 en meer

Bitrix24 is een enorme toolbox die zowel CRM, documentbeheer, als administratie combineert, en nog veel andere dingen biedt die managers erg waarderen, maar minder populair zijn bij IT-personeel. Het portaal wordt veel gebruikt door kleine en middelgrote bedrijven, waaronder kleine klinieken, fabrikanten en zelfs schoonheidssalons. De belangrijkste functie die managers 'geweldig' vinden, is de integratie van telefonie en CRM, waarbij elk telefoontje direct in de CRM wordt vastgelegd, klantkaarten worden aangemaakt, bij een inkomend gesprek informatie over de klant wordt weergegeven en meteen zichtbaar is wie de klant is, wat er kan worden verkocht en hoeveel hij verschuldigd is. Maar de telefonie van Bitrix24 en de integratie met CRM zijn kosten met zich mee, soms aanzienlijke. In dit artikel zal ik mijn ervaringen delen met de integratie van open tools en een populaire IP-telefooncentrale. FreePBX, en ik zal ook de logica van de werking van verschillende onderdelen bekijken.

Ik werk op basis van outsourcing bij een bedrijf dat zich bezighoudt met de verkoop en configuratie van IP-telefonie. Toen ik werd gevraagd of we iets konden voorstellen voor de integratie van Bitrix24 met de centrales die de klanten hebben, evenals met virtuele centrales op verschillende VDS van het bedrijf, ging ik naar Google. En uiteraard gaf Google me een link naar een artikel op Habr, waar zowel een beschrijving als een GitHub te vinden is, en het lijkt allemaal te werken. Maar bij het proberen om deze oplossing te gebruiken, bleek dat Bitrix24 niet meer is wat het ooit was, en dat er veel opnieuw gedaan moet worden. Bovendien, FreePBX is niet zomaar een blote Asterisk; je moet nadenken over hoe je gebruiksgemak en een gecompliceerde belplanning in configuratiebestanden kunt combineren.

Laten we de logica van de werking bestuderen.

Dus laten we beginnen met hoe dit allemaal moet werken. Bij een inkomend telefoontje van buiten naar de centrale (een SIP INVITE gebeurtenis van de provider) begint de verwerking van het belschema (dialplan) - regels over wat te doen met het gesprek en in welke volgorde. Uit het eerste pakket kan veel informatie worden gehaald die later kan worden gebruikt in de regels. Een geweldig hulpmiddel voor het bestuderen van de werking van SIP is een analyzer sngrep (link) die eenvoudig kan worden geïnstalleerd op populaire distributies via apt install/yum install en dergelijke, of je kunt het ook vanuit de broncompileren. Laten we de belregistratie in sngrep bekijken.

In eenvoudige termen houdt het belplan zich alleen bezig met het eerste pakket, soms wordt tijdens het gesprek ook het vertalen van oproepen en het indrukken van knoppen (DTMF) uitgevoerd, evenals verschillende interessante functies zoals FollowMe, RingGroup, IVR en dergelijke.

Wat zit er in het Invite-pakket

Eigenlijk werken de meeste eenvoudige belplannen met de eerste twee velden en draait alle logica om DID en CallerID. DID - naar waar we bellen, CallerID - wie er belt.

Maar we hebben een bedrijf en geen enkele telefoon - en dat betekent dat de PBX waarschijnlijk belgroepen (gelijktijdig/sequentieel bellen van meerdere apparaten) op vaste nummer heeft (Ring Group), IVR (Hallo, u heeft gebeld... Druk op één voor...), Voicemail (Phrases), Tijdvoorwaarden (Time Conditions), Doorverwijzing naar andere nummers of naar mobiele nummers (FollowMe, Forward). Dit betekent dat het erg moeilijk is om precies te bepalen aan wie de oproep daadwerkelijk zal worden doorgegeven en met wie er tijdens de oproep gesproken zal worden. Hier is een voorbeeld van het begin van de doorvoer van een typische oproep in de PBX van onze klanten.

Na succesvolle binnenkomst van de oproep in de PBX, maakt deze een reis door het belplan in verschillende 'contexten'. Context vanuit het perspectief van Asterisk is een genummerde set van commando's, die elk een filter bevatten op het ingetoetste nummer (dit wordt exten genoemd, voor een externe oproep in de beginfase exten=DID). De commando's in de regel van het belplan kunnen van alles zijn - interne functies (bijvoorbeeld bellen met een interne abonnee - Dial(), de hoorn neerleggen - Hangup()), voorwaardelijke operatoren (IF, ELSE, ExecIF en dergelijke), overgangen naar andere regels in deze context (Goto, GotoIF), overgangen naar andere contexten in de vorm van het aanroepen van functies (Gosub, Macro). Apart te noemen is de richtlijn include naam_context, die commando's van een andere context aan het einde van de huidige context toevoegt. Commando's die via include zijn toegevoegd, worden altijd uitgevoerd worden toegevoegd na van de huidige context.

Alle logica van FreePBX is opgebouwd rond het opnemen van verschillende contexten in elkaar via include en aanroepen via Gosub, Macro en Handler-handlers. Laten we de context van inkomende oproepen in FreePBX bekijken.

De oproep gaat in de volgorde van boven naar beneden door alle contexten en in elke context kunnen oproepen van andere contexten als macro's (Macro), functies (Gosub) of gewoon overgangen (Goto) worden uitgevoerd, daarom kan de daadwerkelijke hiërarchie van wat wordt aangeroepen alleen in de logs worden gevolgd.

Het typische configuratieschema voor een typische kantoor-telefooncentrale wordt hieronder weergegeven. Bij inkomende oproepen wordt de DID gezocht, die vervolgens aan de tijdsvoorwaarden wordt gecontroleerd. Als alles in orde is, wordt het spraakmenu gestart. Van daaruit is er via knop 1 of een timeout toegang tot de groep van operators. Na afloop van de oproep wordt de macro hangupcall aangeroepen, waarna er niets meer in het dialplan kan worden uitgevoerd, behalve speciale handlers (hangup handler).

Waar in dit belproces moeten we informatie over het begin van de oproep naar de CRM sturen, waar moeten we de opname starten, waar moeten we de opname beëindigen en deze samen met informatie over de oproep naar de CRM verzenden?

Integratie met externe systemen

Wat is de integratie tussen een telefooncentrale en CRM? Dit zijn instellingen en programma's die gegevens en gebeurtenissen tussen deze twee platforms converteren en naar elkaar verzenden. De meest voorkomende manier van interactie tussen onafhankelijke systemen is via een API, en de meest populaire manier om toegang te krijgen tot de API is via HTTP REST. Maar zeker niet voor Asterisk.

Binnen Asterisk is er:

AGI — synchrone oproep naar externe programma's/componenten, voornamelijk gebruikt in het dialplan, er zijn bibliotheken zoals phpagi, PAGI
AMI — een tekstuele TCP-socket die functioneert op basis van het abonneren op gebeurtenissen en het invoeren van tekstcommando's; het lijkt van binnen op SMTP, kan gebeurtenissen volgen en oproepen beheren, er is een bibliotheek PAMI — de populairste om verbinding met Asterisk te maken

Voorbeeld van AMI-uitvoer

Event: Newchannel
Privilege: call,all
Channel: PJSIP/VMS_pjsip-0000078b
ChannelState: 4
ChannelStateDesc: Ring
CallerIDNum: 111222
CallerIDName: 111222
ConnectedLineNum:
ConnectedLineName:
Language: en
AccountCode:
Context: from-pstn
Exten: s
Priority: 1
Uniqueid: 1599589046.5244
Linkedid: 1599589046.5244

ARI — een mix van het een en het ander, alles via REST, WebSocket, in JSON-formaat — maar met recente bibliotheken en wrappers is het niet zo goed gesteld, hierbij heb ik (phparia, phpari) die al drie jaar stil staan in hun ontwikkeling.

Voorbeeld van ARI-uitvoer bij het initiëren van een oproep

{ "variable":"CallMeCallerIDName", "value":"111222", "type":"ChannelVarset", "timestamp":"2020-09-09T09:38:36.269+0000", "channel":{ "id":"1599644315.5334", "name":"PJSIP/VMSpjsip-000007b6", "state":"Ring", "caller":{ "name":"111222", "number":"111222" }, "connected":{ "name":"", "number":"" }, "accountcode":"", "dialplan":{ "context":"from-pstn", "exten":"s", "priority":2, "appname":"Stasis", "appdata":"hello-world" }, "creationtime":"2020-09-09T09:38:35.926+0000", "language":"ru" }, "asteriskid":"48:5b:aa:aa:aa:aa", "application":"hello-world" }

Het gemak of ongemak, de mogelijkheid of onmogelijkheid om met een bepaalde API te werken, hangt af van de taken die moeten worden opgelost. De taken voor integratie met CRM zijn als volgt:

Volg het begin van de oproep, waar deze naartoe is doorgeschakeld, haal de CallerID, DID, begin- en eindtijden op, mogelijk gegevens uit de directory (voor het vinden van de relatie tussen telefoon en CRM-gebruiker)
Begin en eindig de opname van de oproep, sla op in het juiste formaat, informeer na het beëindigen van de opname waar het bestand is opgeslagen
Initieer een oproep op basis van een externe gebeurtenis (uit het programma), bel een intern nummer, een extern nummer en verbind ze
Optioneel: integreer met CRM, belgroepen en FollowME voor automatische doorschakeling van oproepen wanneer niet aanwezig (op basis van CRM-informatie)

Al deze taken kunnen worden opgelost via AMI of ARI, maar ARI biedt veel minder informatie, er zijn veel gebeurtenissen die niet worden gevolgd, en veel variabelen die in AMI wel aanwezig zijn (bijvoorbeeld macro-aanroepen, het instellen van variabelen binnen macro's, inclusief het opnemen van oproepen). Daarom, voor een juiste en nauwkeurige tracking — kiezen we voorlopig voor AMI (maar niet definitief). Bovendien (nou ja, waar zouden we zonder, we zijn mensen die lui zijn) — in het oorspronkelijke werk (artikel op Habr) gebruik PAMI. *Daarna moeten we proberen het opnieuw te schrijven op ARI, maar het is niet zeker of dit lukt.

We bedenken de integratie opnieuw

Om ervoor te zorgen dat onze FreePBX op eenvoudige manieren kan rapporteren aan AMI over het begin van de oproep, de eindtijd, de nummers, de namen van de opgenomen bestanden, is het het eenvoudigste om dezelfde truc te gebruiken als de oorspronkelijke auteurs — voer je eigen variabelen in en parse de output op hun aanwezigheid. PAMI biedt een gemakkelijke manier om dit te doen via een filterfunctie.

Hier is een voorbeeld van het instellen van je eigen variabele voor de tijd van het begin van de oproep (s is een speciale nummer in het dialplan, dat wordt uitgevoerd VOORDAT het zoeken op DID begint)

[ext-did-custom]

exten => s,1,Set(CallStart=${STRFTIME(epoch,,%s)})

Voorbeeld AMI-gebeurtenis volgens deze regel

Event: Newchannel

Privilege: call,all

Channel: PJSIP/VMS_pjsip-0000078b

ChannelState: 4

ChannelStateDesc: Ring

CallerIDNum: 111222

CallerIDName: 111222

ConnectedLineNum:

ConnectedLineName:

Language: en

AccountCode:

Context: from-pstn

Exten: s

Priority: 1

Uniqueid: 1599589046.5244

Linkedid: 1599589046.5244

Toepassing: Set AppData:

CallStart=1599571046

Aangezien FreePBX de bestanden extention.conf en extention_additional.conf opnieuw schrijft, zullen we het bestand extention_custom.conf

Volledige code extention_custom.conf

[globals]	
;; Controleer de paden en de rechten van de mappen - gebruiker asterisk moet schrijfrechten hebben
;; Gesprekken worden hier opgeslagen
WAV=\/var\/www\/html\/callme\/records\/wav 
MP3=\/var\/www\/html\/callme\/records\/mp3

;; Op deze paden worden de opnames afgespeeld en gedownload
URLRECORDS=https:\/\/www.host.ru\/callmeplus\/records\/mp3

;; Adres voor de callback bij een uitgaande oproep
URLPHP=https:\/\/www.host.ru\/callmeplus

;; Ja, we schrijven gesprekken op
RECORDING=1

;; Dit is de macro voor het opnemen van gesprekken in onze map.
;; Je kunt ook de systeemopname gebruiken, maar laten we voorlopig deze houden - 
;; hij werkt
[recording]
exten => ~~s~~,1,Set(LOCAL(calling)=${ARG1})
exten => ~~s~~,2,Set(LOCAL(called)=${ARG2})
exten => ~~s~~,3,GotoIf($["${RECORDING}" = "1"]?4:14)
exten => ~~s~~,4,Set(fname=${UNIQUEID}-${STRFTIME(${EPOCH},,%Y-%m-%d-%H_%M)}-${calling}-${called})
exten => ~~s~~,5,Set(datedir=${STRFTIME(${EPOCH},,%Y\/%m\/%d)})
exten => ~~s~~,6,System(mkdir -p ${MP3}\/${datedir})
exten => ~~s~~,7,System(mkdir -p ${WAV}\/${datedir})
exten => ~~s~~,8,Set(monopt=nice -n 19 \/usr\/bin\/lame -b 32  --silent "${WAV}\/${datedir}\/${fname}.wav"  "${MP3}\/${datedir}\/${fname}.mp3" && rm -f "${WAV}\/${fname}.wav" && chmod o+r "${MP3}\/${datedir}\/${fname}.mp3")
exten => ~~s~~,9,Set(FullFname=${URLRECORDS}\/${datedir}\/${fname}.mp3)
exten => ~~s~~,10,Set(CDR(filename)=${fname}.mp3)
exten => ~~s~~,11,Set(CDR(recordingfile)=${fname}.wav)
exten => ~~s~~,12,Set(CDR(realdst)=${called})
exten => ~~s~~,13,MixMonitor(${WAV}\/${datedir}\/${fname}.wav,b,${monopt})
exten => ~~s~~,14,NoOp(Finish if_recording_1)
exten => ~~s~~,15,Return()


;; Dit is de hoofdcontext voor het beginnen van een gesprek
[ext-did-custom]

;; Dit is een grap, om dit zo te doen en hier, maar het werkt - we voegen '8' toe aan het nummer
exten =>  s,1,Set(CALLERID(num)=8${CALLERID(num)})

;; Hier enkele variabelen voor het script
exten =>  s,n,Gosub(recording,~~s~~,1(${CALLERID(number)},${EXTEN}))
exten =>  s,n,ExecIF(${CallMeCallerIDName}?Set(CALLERID(name)=${CallMeCallerIDName}):NoOp())
exten =>  s,n,Set(CallStart=${STRFTIME(epoch,,%s)})
exten =>  s,n,Set(CallMeDISPOSITION=${CDR(disposition)})

;; Het belangrijkste! De handler voor het beëindigen van het gesprek. 
;; Gebruikelijke manieren om het einde te verwerken via (exten=>h,1,... in FreePBX werken niet - Macro(hangupcall,) verstoort alles. 
;; Daarom hangen we de Hangup_Handler aan het beëindigen van de oproep
exten => s,n,Set(CHANNEL(hangup_handler_push)=sub-call-from-cid-ended,s,1(${CALLERID(num)},${EXTEN}))

;; Handler voor het beëindigen van een inkomende oproep
[sub-call-from-cid-ended]

;; We melden de waarden bij het beëindigen van de oproep
exten => s,1,Set(CDR_PROP(disable)=true)
exten => s,n,Set(CallStop=${STRFTIME(epoch,,%s)})
exten => s,n,Set(CallMeDURATION=${MATH(${CallStop}-${CallStart},int)})

;; Status van de oproep - Beantwoord, niet beantwoord...
exten => s,n,Set(CallMeDISPOSITION=${CDR(disposition)})
exten => s,n,Return


;; Handler voor uitgaande oproepen - alles is vergelijkbaar
[outbound-allroutes-custom]

;; Opname
exten => _.,1,Gosub(recording,~~s~~,1(${CALLERID(number)},${EXTEN}))
;; Variabelen
exten => _.,n,Set(__CallIntNum=${CALLERID(num)})
exten => _.,n,Set(CallExtNum=${EXTEN})
exten => _.,n,Set(CallStart=${STRFTIME(epoch,,%s)})
exten => _.,n,Set(CallmeCALLID=${SIPCALLID})

;; We hangen de Hangup_Handler aan het beëindigen van de oproep
exten => _.,n,Set(CHANNEL(hangup_handler_push)=sub-call-internal-ended,s,1(${CALLERID(num)},${EXTEN}))

;; Handler voor het beëindigen van een uitgaande oproep
[sub-call-internal-ended]

;; variabelen
exten => s,1,Set(CDR_PROP(disable)=true)
exten => s,n,Set(CallStop=${STRFTIME(epoch,,%s)})
exten => s,n,Set(CallMeDURATION=${MATH(${CallStop}-${CallStart},int)})
exten => s,n,Set(CallMeDISPOSITION=${CDR(disposition)})

;; Oproep van het script dat melding maakt van de oproep in CRM - dit is uitgaand, 
;; dus feitelijk bij het beëindigen
exten => s,n,System(curl -s ${URLPHP}\/CallMeOut.php --data action=sendcall2b24 --data ExtNum=${CallExtNum} --data call_id=${SIPCALLID} --data-urlencode FullFname='${FullFname}' --data CallIntNum=${CallIntNum} --data CallDuration=${CallMeDURATION} --data-urlencode CallDisposition='${CallMeDISPOSITION}')
exten => s,n,Return

Kenmerk en verschil met het originele dialplan van de auteurs van het oorspronkelijke artikel —

Dialplan in .conf formaat, zoals FreePBX dat wil (ja, het ondersteunt .ael, maar niet alle versies en niet altijd is dat handig)
In plaats van het verwerken van het einde via exten=>h, is er verwerking via hangup_handler ingevoerd, omdat het FreePBX-dialplan alleen met hem werkt
De oproepregel voor het script is gecorrigeerd, aanhalingstekens en het externe nummer ExtNum zijn toegevoegd
Verwerkingen zijn verplaatst naar _custom contexten en stellen je in staat om de FreePBX-configuraties niet aan te raken of aan te passen — binnenkomend via [ext-did-custom], uitgaand via [outbound-allroutes-custom]
Geen nummerbinding — het bestand is universeel en vereist alleen configuratie van het pad en de link naar de server

Om te beginnen moet je de scripts in AMI starten met een login en wachtwoord — hiervoor is er ook een _custom bestand in FreePBX

Bestand manager_custom.conf

;; dit is de login
[callmeplus]
;; dit is het wachtwoord
secret = trampampamturlala
deny = 0.0.0.0/0.0.0.0

;; ik werk met een lokale machine - maar als het nodig is, kunnen er ook andere worden opgegeven
permit = 127.0.0.1/255.255.255.255
read = system,call,log,verbose,agent,user,config,dtmf,reporting,cdr,dialplan
write = system,call,agent,log,verbose,user,config,command,reporting,originate

Deze beide bestanden moeten in /etc/asterisk worden geplaatst, daarna moeten de configuraties opnieuw worden gelezen (of Asterisk opnieuw worden opgestart)

# astrisk -rv
  Connected to Asterisk 16.6.2 currently running on freepbx (pid = 31629)
#freepbx*CLI> dialplan reload
     Dialplan reloaded.
#freepbx*CLI> exit

Laten we nu overgaan naar PHP

Initialisatie van scripts en het creëren van een service

Aangezien het werken met Bitrix 24, de service voor AMI, niet helemaal eenvoudig en transparant is, moet hier apart bij stilgestaan worden. Bij het activeren van AMI opent Asterisk gewoon een poort en dat is alles. Bij het aansluiten van de client vraagt deze om autorisatie, daarna abonneert de client zich op de benodigde evenementen. De evenementen komen als gewone tekst binnen, die PAMI omzet in gestructureerde objecten en de mogelijkheid biedt om een filterfunctie in te stellen op alleen de interessante evenementen, velden, nummers, enzovoort.

Zodra de oproep binnenkomt, ontstaat het evenement NewExten beginnend met de bovenliggende context [from-pstn], daarna volgen alle gebeurtenissen in volgorde van de regels in de contexten. Bij het ontvangen van informatie uit de gedefinieerde _custom variabelen CallMeCallerIDName en CallStart wordt erop ingegaan.

De functie vraagt om de UserID, die overeenkomt met het interne nummer waar de oproep binnenkomt. En wat als het een belgroep is? Dit is een politiek vraagstuk: moeten we allemaal tegelijk bellen (wanneer iedereen tegelijkertijd belt) of moeten we bellen naarmate we bellen in volgorde? De meeste klanten hebben de strategie First Available ingesteld, dus hier zijn geen problemen, er belt maar één persoon. Maar het probleem moet opgelost worden.
De functie voor het registreren van oproepen in Bitrix24, die de CallID teruggeeft, wat later nodig is voor het rapporteren van de oproepparameters en de link naar de opname. Vereist of een intern nummer of een UserID.

Na het beëindigen van de oproep wordt de functie voor het uploaden van de opname aangeroepen, die tegelijkertijd de status van de oproep beëindiging aangeeft (Bezet, Geen antwoord, Succes), en ook de link naar het mp3-bestand met de opname uploadt (indien aanwezig).

Aangezien de module CallMeIn.php continu moet draaien, is er een SystemD startbestand voor gemaakt. callme.service, dat moet worden geplaatst in /etc/systemd/system/callme.service.

[Unit]
Description=CallMe

[Service]
WorkingDirectory=/var/www/html/callmeplus
ExecStart=/usr/bin/php /var/www/html/callmeplus/CallMeIn.php 2>&1 >>/var/log/callmeplus.log
ExecStop=/bin/kill -WINCH ${MAINPID}
KillSignal=SIGKILL

Restart=on-failure
RestartSec=10s

# hier moet worden gekeken welke rechten op de mappen zijn
#User=www-data  #Ubuntu - debian
#User=nginx #Centos

[Install]
WantedBy=multi-user.target

De initialisatie en het starten van het script gebeurt via systemctl of service.

# systemctl enable callme
# systemctl start callme

De service zal automatisch opnieuw opstarten indien nodig (bij uitval). De service voor het volgen van binnenkomende oproepen vereist geen installatie van een webserver, alleen php is nodig (wat zeker aanwezig is op de FeePBX-server). Maar zonder toegang tot de oproepopnamen via de webserver (ook met https) is er geen mogelijkheid om de gespreksopnamen te beluisteren.

Laten we het nu hebben over uitgaande oproepen. Het script CallMeOut.php heeft twee functies:

Initiëren van een oproep bij het ontvangen van een verzoek op de php-script (inclusief op de knop 'Bel' in Bitrix zelf). Het werkt niet zonder een webserver, het verzoek komt binnen via HTTP POST, met daarin een token.
Informatie over de oproep, zijn parameters en opnamen naar Bitrix. Dit gebeurt op initiatief van Asterisk in het belplan [sub-call-internal-ended] bij het beëindigen van de oproep.

De webserver is alleen nodig voor twee zaken - uploading van opnamebestanden naar Bitrix (via HTTPS) en het aanroepen van het script CallMeOut.php. Je kunt de ingebouwde server van FreePBX gebruiken, waarvan de bestanden zich bevinden in /var/www/html, of een andere server installeren of een ander pad opgeven.

Webserver

Laten we de configuratie van de webserver aan je zelfstudie overlaten (klik hier, klik hier, klik hier). Als je nog geen domein hebt, kun je FreeDomain proberen ( https://www.freenom.com/ru/index.html), die je gratis een naam zullen geven voor je publieke IP (vergeet niet de poorten 80, 443 via de router door te geven als je alleen een extern adres op deze router hebt). Als je pas een DNS-domein hebt aangemaakt, moet je wachten (van 15 minuten tot 48 uur) totdat alle servers zijn geladen. Uit ervaring met binnenlandse providers — van 1 uur tot een dag.

Automatisering van installatie

Op GitHub is de ontwikkeling van een installer gestart, zodat je het nog eenvoudiger kunt installeren. Maar glad was het op papier — tot nu toe installeren we dit handmatig, gelukkig is het na wat geknoei met alles kristalhelder geworden wie met wie omgaat, waar iedereen naartoe gaat en hoe dit te debuggen. De installer is er nog niet (

Docker

Als je snel een oplossing wilt uitproberen — er is een optie met Docker — snel een container maken, deze poorten naar buiten geven, configuratiebestanden doorgeven en uitproberen (dit is de optie met de LetsEncrypt-container, als je al een certificaat hebt, hoef je alleen de omgekeerde proxy naar de webserver FreePBX door te sturen (hiervoor hebben we een andere poort gegeven — 88), LetsEncrypt in Docker gebaseerd op dit artikel

Je moet het bestand uitvoeren in de gedownloade projectmap (na git clone), maar eerst de configuraties van Asterisk (map asterisk) bekijken en daar de paden naar de bestanden en de URL van je site invoeren.

version: '3.3'
services:
  nginx:
    image: nginx:1.15-alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - .\/nginx\/ssl_docker.conf:\etc\/nginx\/conf.d\/ssl_docker.conf
  certbot:
    image: certbot\/certbot
  freepbx:
    image: flaviostutz\/freepbx
    ports:
      - 88:80 # voor configuratie
      - 5060:5060\/udp
      - 5160:5160\/udp
      - 127.0.0.1:5038:5038 # voor CallMeOut.php
#      - 3306:3306
      - 18000-18100:18000-18100\/udp
    restart: always
    environment:
      - ADMIN_PASSWORD=admin123
    volumes:
      - backup:\backup
      - recordings:\var\/spool\/asterisk\/monitor
      - .\/callme:\var\/www\/html\/callme
      - .\/systemd\/callme.service:\etc\/systemd\/system\/callme.conf
      - .\/asterisk\/manager_custom.conf:\etc\/asterisk\/manager_custom.conf
      - .\/asterisk\/extensions_custom.conf:\etc\/asterisk\/extensions_custom.conf
#      - .\/conf\/startup.sh:\startup.sh

volumes:
  backup:
  recordings:

Dit docker-compose.yaml-bestand wordt uitgevoerd via

docker-compose up -d

Als nginx niet gestart is, betekent dit dat er iets mis is met de configuratie in de map nginx\/ssl_docker.conf.

Andere integraties

Waarom niet gelijk een paar CRM's in de scripts stoppen, dachten wij. We hebben verschillende API's van andere CRM's onderzocht, vooral de gratis ingebouwde in sommige PBX-systemen — ShugarCRM en Vtiger, en ja! het kan, het principe is hetzelfde. Maar dat is weer een ander verhaal, dat we later apart op GitHub zullen plaatsen.

Links