--- title: "Mengirim surel" version: 2.1 locale: id source: https://docs.djangoproject.com/id/2.1/topics/email/ canonical: https://djangodocs.dev/id/2.1/topics/email/ --- # Mengirim surel Meskipun Python membuat mengirim surel cenderung mudah melalui modul [`smtplib`](https://docs.python.org/3/library/smtplib.html#module-smtplib), Django menyediakan salinan ringan yang membungkusnya. Pembungkus ini disediakan untuk membuat pengiriman surel ekstra cepat, untuk membuatnya mudah mengirim surel selama pengembangan, dan untuk menyediakan dukungan untuk serambi yang tidak dapat menggunakan SMTP. Kode tinggal dalam modul `django.core.mail`. ## Contoh cepat Dalam dua baris: ``` from django.core.mail import send_mail send_mail( 'Subject here', 'Here is the message.', 'from@example.com', ['to@example.com'], fail_silently=False, ) ``` Surat dikirim menggunakan rumah SMTP dan port ditentukan dalam pengaturan [`EMAIL_HOST`](/id/2.1/ref/settings/#std-setting-EMAIL_HOST) dan [`EMAIL_PORT`](/id/2.1/ref/settings/#std-setting-EMAIL_PORT). Pengaturan [`EMAIL_HOST_USER`](/id/2.1/ref/settings/#std-setting-EMAIL_HOST_USER) dan [`EMAIL_HOST_PASSWORD`](/id/2.1/ref/settings/#std-setting-EMAIL_HOST_PASSWORD) settings, jika disetel, digunakan untuk mengotentifikasi pada peladen SMTP, dan pengaturan [`EMAIL_USE_TLS`](/id/2.1/ref/settings/#std-setting-EMAIL_USE_TLS) dan [`EMAIL_USE_SSL`](/id/2.1/ref/settings/#std-setting-EMAIL_USE_SSL) mengendalikan apakah hubungan aman digunakan. > **Note** > > Kumpulan karakter dari surel dikirim dengan `django.core.mail` akan disetel ke nilai dari pengaturan [`DEFAULT_CHARSET`](/id/2.1/ref/settings/#std-setting-DEFAULT_CHARSET) anda. ## `send_mail()` #### `send_mail(subject, message, from_email, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None, html_message=None)` Cara termudah mengirim surel adalah menggunakan `django.core.mail.send_mail()`. Parameter `subject`, `message`, `from_email` dan `recipient_list` dibutuhkan. - `subject`: Sebuah string. - `message`: Sebuah string. - `from_email`: Sebuah string. - `recipient_list`: Sebuah daftar dari string, setiap alamat surel. Setiap anggota dari `recipient_list` akan melihat penerima lain dalam bidang "To:" dari pesan surel. - `fail_silently`: A boolean. When it's `False`, `send_mail()` will raise an [`smtplib.SMTPException`](https://docs.python.org/3/library/smtplib.html#smtplib.SMTPException) if an error occurs. See the [`smtplib`](https://docs.python.org/3/library/smtplib.html#module-smtplib) docs for a list of possible exceptions, all of which are subclasses of [`SMTPException`](https://docs.python.org/3/library/smtplib.html#smtplib.SMTPException). - `auth_user`: Pilihan nama pengguna untuk digunakan mengautentifikasi ke peladen SMTP. Jika ini tidak disediakan, Django akan menggunakan nilai dari pengaturan [`EMAIL_HOST_USER`](/id/2.1/ref/settings/#std-setting-EMAIL_HOST_USER). - `auth_password`: Sandi pilihan digunakan untuk mengautentifikasi ke peladen SMTP. Jika ini tidak disediakan, Django akan menggunakan nilai dari pengaturan [`EMAIL_HOST_PASSWORD`](/id/2.1/ref/settings/#std-setting-EMAIL_HOST_PASSWORD) - `connection`: Backend surel pilihan digunakan untuk mengirim surat. Jika tidak ditentukan, sebuah instance dari backend awalan akan digunakan. Lihat dokumentasi pada Email backends 1 untuk rincian lebih. - `html_message`: Jika `html_message` disediakan, surel dihasilkan akan berupa surel `multipart/alternative` dengan `message` sebagai jenis isi `text/plain` dan `html_message` sebagai jenis isi `text/html`. Nilai kembalian akan berupa angka dari pesan terkirim yang berhasil (yang dapat berupa `0` atau `1` sejak itu hanya daoat mengirim satu pesan). ## `send_mass_mail()` #### `send_mass_mail(datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None)` `django.core.mail.send_mass_mail()` diperuntukkan untuk menangani penyuratan elektronik masal. `datatuple` adalah sebuah tuple yang setiap unsur adalah dalam bentuk ini: ``` (subject, message, from_email, recipient_list) ``` `fail_silently`, `auth_user` dan `auth_password` mempunyai fungsi sama seperti dalam [`send_mail()`](#django.core.mail.send_mail). Setiap unsur terpisah dari `datatuple` menghasilkan dalam pesan surel terpisah. Seperti dalam [`send_mail()`](#django.core.mail.send_mail), penerima dalam `recipient_list` sama akan semua melihat alamat-alamat lain dalam pesan surel' bidang "To:". Sebagai contoh, kode berikut akan mengirim dua pesan berbeda pada dua kumpulan berbeda dari penerima; bagaimanapun, hanya satu hubungan ke peladen surat akan dibuka: ``` message1 = ('Subject here', 'Here is the message', 'from@example.com', ['first@example.com', 'other@example.com']) message2 = ('Another Subject', 'Here is another message', 'from@example.com', ['second@test.com']) send_mass_mail((message1, message2), fail_silently=False) ``` Nilai kembalian akan berupa angka dari pesan terkirim berhasil. ### `send_mass_mail()` x `send_mail()` Perbedaan utama diantara [`send_mass_mail()`](#django.core.mail.send_mass_mail) dan [`send_mail()`](#django.core.mail.send_mail) adalah bahwa [`send_mail()`](#django.core.mail.send_mail) membuka sebuah hubungan ke peladen surel setiap itu dijalankan, selagi [`send_mass_mail()`](#django.core.mail.send_mass_mail) menggunakan hubungan tunggal untuk semua pesan-pesannya. Ini membuat [`send_mass_mail()`](#django.core.mail.send_mass_mail) sedikit lebih efesien. ## `mail_admins()` #### `mail_admins(subject, message, fail_silently=False, connection=None, html_message=None)` `django.core.mail.mail_admins()` adalah jalan pintas untuk mengirim sebuah surel pada admin situs, seperti ditentukan dalam pengaturan [`ADMINS`](/id/2.1/ref/settings/#std-setting-ADMINS). `mail_admins()` mengawali subyek dengan nilai dari pengaturan [`EMAIL_SUBJECT_PREFIX`](/id/2.1/ref/settings/#std-setting-EMAIL_SUBJECT_PREFIX), yaitu `"[Django] "` secara awalan. Kepala "From:" dari surel akan berupa nilai dari pengaturan [`SERVER_EMAIL`](/id/2.1/ref/settings/#std-setting-SERVER_EMAIL). Metode ini ada untuk kenyamanan dan kesiapan. Jika `html_message` disediakan, surel dihasilkan akan berupa surel `multipart/alternative` dengan `message` seperti jenis isi `text/plain` dan `html_message` seperti jenis isi `text/html`. ## `mail_managers()` #### `mail_managers(subject, message, fail_silently=False, connection=None, html_message=None)` `django.core.mail.mail_managers()` seperti `mail_admins()`, kecuali itu mengirim sebuah surel ke pengelola situs, seperti ditentukan dalam pengaturan [`MANAGERS`](/id/2.1/ref/settings/#std-setting-MANAGERS). ## Contoh Ini mengirim surel tunggal kepada [john@example.com](mailto:john@example.com) dan [jane@example.com](mailto:jane@example.com), dengan keduanya mereka muncul dalam "To:": ``` send_mail( 'Subject', 'Message.', 'from@example.com', ['john@example.com', 'jane@example.com'], ) ``` Ini mengirim sebuah pesan ke [john@example.com](mailto:john@example.com) dan [jane@example.com](mailto:jane@example.com), dengan keduanya menerima surel terpisah: ``` datatuple = ( ('Subject', 'Message.', 'from@example.com', ['john@example.com']), ('Subject', 'Message.', 'from@example.com', ['jane@example.com']), ) send_mass_mail(datatuple) ``` ## Mencegah penyuntikan kepala [Header injection](http://www.nyphp.org/phundamentals/8_Preventing-Email-Header-Injection) adalah memanfaatkan keamanan dimana seorang penyerang memasukkan kepala surel tambahan untuk mengendalikan "To:" dan "From:" dalam pesan-pesan surel yang tulisan-tulisan anda dibangkitkan. Fungsi-fungsi surel Django diuraikan diatas semua dilindungi terhadap suntukan kepala dengan melarang baris baru dalam nilai kepala. Jika ada `subject`, `from_email` atau `recepient_list` mengandung sebuah baris baru (dalam salah satu gaya Unix, Windows, atau Mac), fungsi surel (sebagai contoh [`send_mail()`](#django.core.mail.send_mail)) akan memunculkan `django.core.mail.BadHeaderError` (sebuah subkelas dari `ValueError`) dan, karenanya, tidak akan mengirim surel. Itu adalah tanggung jawab anda untuk mengesahkan semua data sebelum melewatkan itu ke fungsi-fungsi surel. Jika sebuah `message` mengandung kepala-kepala pada awal dari string, kepala-kepala akan cukup dicetak sebagai bit pertama dari pesan surel. Ini adalah sebuah contoh tampilan yang mengambil `subject`, `message` dan `from_email` dari data POST permintaan, mengirim itu ke [admin@example.com](mailto:admin@example.com) dan mengalihkan ke "/contact/thanks/" ketika itu selesai: ``` from django.core.mail import BadHeaderError, send_mail from django.http import HttpResponse, HttpResponseRedirect def send_email(request): subject = request.POST.get('subject', '') message = request.POST.get('message', '') from_email = request.POST.get('from_email', '') if subject and message and from_email: try: send_mail(subject, message, from_email, ['admin@example.com']) except BadHeaderError: return HttpResponse('Invalid header found.') return HttpResponseRedirect('/contact/thanks/') else: # In reality we'd use a form class # to get proper validation errors. return HttpResponse('Make sure all fields are entered and valid.') ``` ## Kelas `EmailMessage` Fungsi-fungsi [`send_mail()`](#django.core.mail.send_mail) dan [`send_mass_mail()`](#django.core.mail.send_mass_mail) sebenarnya pembungkus kecil yang memanfaatkan dari kelas [`EmailMessage`](#django.core.mail.EmailMessage). Tidak semua fitur dari kelas [`EmailMessage`](#django.core.mail.EmailMessage) tersedia melalui [`send_mail()`](#django.core.mail.send_mail) dan fungsi-fungsi pembungkus terkait. Jika anda menginginkan menggunakan fitur-fitur lanjutan, seperti penerima BCC, lampiran berkas, atau banyak-bagian surel, anda akan butuh membuat instance [`EmailMessage`](#django.core.mail.EmailMessage) langsung. > **Note** > > Ini adalah fitur rancangan. [`send_mail()`](#django.core.mail.send_mail) dan fungsi-fungsi terkait aslinya hanya antarmuka Django sediakan. Bagaimanapun, daftar dari parameter mereka terima pelan-pelan tumbuh terhadap waktu. Itu masuk akal memindahkan rancangan berorientasi-obyek untuk pesan-pesan surel dan memelihara fungsi-fungsi asli hanya untuk kesesuaian kebelakang. [`EmailMessage`](#django.core.mail.EmailMessage) bertanggungjawab untuk membuat pesan surel itu sendiri. email backend 1 kemudian bertanggungjawab untuk mengirim surel. Untuk kenyamanan, [`EmailMessage`](#django.core.mail.EmailMessage) menyediakan metode `send()` sederhana untuk mengirim surel tunggal. Jika anda butuh mengirim banyak pesan, API backend surel provides an alternative 1. ### Obyek `EmailMessage` #### `class EmailMessage` Kelas [`EmailMessage`](#django.core.mail.EmailMessage) diawalkan dengan parameter-parameter berikut (dalam urutan diberikan, jika penempatan argumen-argumen digunakan). Semua parameter adalah pilihan dan dapat disetel pada waktu kapanpun sebelum memanggil metode `send()`. - `subject`: Pokok baris dari surel. - `body`: Teks badan. Ini harus berupa pesan teks polos. - `from_email`: Alamat pengirim. Kedua bentuk `fred@example.com` dan `Fred ` adalah sah. Jika dihilangkan, pengaturan [`DEFAULT_FROM_EMAIL`](/id/2.1/ref/settings/#std-setting-DEFAULT_FROM_EMAIL) digunakan. - `to`: Sebuah list atau tuple dari alamat-alamat penerima. - `bcc`: Sebuah list atau tuple dari alamat-alamat digunakan dalam kepala "Bcc" ketika mengirim surel. - `connection`: Sebuah instance backend surel. Gunakan parameter ini jika anda ingin menggunakan hubungan sama untuk banyak pesan-pesan. Jika dihilangkan, hubungan baru dibuat ketika `send()` dipanggil. - `attachments`: A list of attachments to put on the message. These can be either [`MIMEBase`](https://docs.python.org/3/library/email.mime.html#email.mime.base.MIMEBase) instances, or `(filename, content, mimetype)` triples. - `header`: Sebuah dictionary dari kepala tambahan untuk menaruh pesan. Kunci-kunci adalah nama kepala, nilai-nilai adalah nilai-nilai kepala. Itu terserah pada pemanggil untuk memastikan nama=nama dan nilai-nilai dalam bentuk benar untuk pesan surel. Atribut sesuai adalah `extra_headers`. - `cc`: Sebuah list atau tuple dari alamat-alamat penerima digunakan dalam kepala "Cc" ketika mengirim surel. - `reply_to`: Sebuah list atau tuple dari alamat-alamat penerima dalam kepala "Reply-To" ketika mengirim surel. Sebagai contoh: ``` from django.core.mail import EmailMessage email = EmailMessage( 'Hello', 'Body goes here', 'from@example.com', ['to1@example.com', 'to2@example.com'], ['bcc@example.com'], reply_to=['another@example.com'], headers={'Message-ID': 'foo'}, ) ``` Kelas mempunyai cara berikut: - `send(fail_silently=False)` mengirim pesan. Jika hubungan telah ditentukan ketika surel dibangun, hubungan itu akan digunakan. Sebalinya, sebuah instance dari backend awalan akan diinstasiasikan dan digunakan. Jika argumen kata kunci fail\_silently\` adalah `True`, pengecualian dimunculkan ketika mengirim pesan akan dibatalkan. Sebuah daftar kosong dari penerima tidak akan memunculkan sebuah pengecualian. - `message()` constructs a `django.core.mail.SafeMIMEText` object (a subclass of Python's [`MIMEText`](https://docs.python.org/3/library/email.mime.html#email.mime.text.MIMEText) class) or a `django.core.mail.SafeMIMEMultipart` object holding the message to be sent. If you ever need to extend the [`EmailMessage`](#django.core.mail.EmailMessage) class, you'll probably want to override this method to put the content you want into the MIME object. - `recipients()` mengembalikan daftar dari semua penerima dari pesan, apakah mereka adalah terekam dalam atribut `to`, `cc` atau `bcc`. Ini adalah metode lain anda mungkin butuh untuk menimpa ketika mensubkelaskan, karena peladen SMTP butuh diberitahu daftar penuh dari penerima ketika pesan dikirim. Jika anda menambah cara lain untuk menentukan penerima dalam kelas anda, mereka butuh dikembalikan dari metode ini juga. - `attach()` membuat lampiran berkas baru dan menambahkan itu ke pesan. Ada dua cara memanggil `attach()`: - You can pass it a single argument that is a [`MIMEBase`](https://docs.python.org/3/library/email.mime.html#email.mime.base.MIMEBase) instance. This will be inserted directly into the resulting message. - Kalau tidak, anda dapat melewatkan tiga argumen `attach()`: `filename`, `content` dan `mimetype`. `filename` adalah nama dari lampiran berkas ketika itu muncul dalam surel, `content` adalah data yang akan di isi didalam lampiran dan `mimetype` adalah jenis MIME untuk lampiran. Jika anda menghilangkan `mimetype`, jenis isi MIME akan ditebak dari nama berkas dari lampiran. Sebagai contoh: ``` message.attach('design.png', img_data, 'image/png') ``` Jika anda menentukan `mimetype` dari `message/rfc822`, itu juga akan menerima [`django.core.mail.EmailMessage`](#django.core.mail.EmailMessage) dan [`email.message.Message`](https://docs.python.org/3/library/email.compat32-message.html#email.message.Message). Untuk `mimetype` dimulai dengan `text/`, konteks diharapkan berupa string. Data biner akan disandikan menggunakan UTF-8, dan jka itu gagal, jenis MIME akan dirubah menjadi `application/octet-stream` dan data akan dilampirkan tidak berubah. Sebagai tambahan, lampiran-lampiran `message/rfc822` tidak lama lagi berupa disandi-base64 dalam pelanggaran dari [**RFC 2046 Section 5.2.1**](https://datatracker.ietf.org/doc/html/rfc2046.html#section-5.2.1), yang dapat menyebabkan masalah-masalah dengan menampilkan lampiran dalam [Evolution](https://bugzilla.gnome.org/show_bug.cgi?id=651197) dan [Thunderbird](https://bugzilla.mozilla.org/show_bug.cgi?id=333880). - `attach_file()` membuat sebuah lampiran baru menggunakan sebuah berkas dari sistem berkas anda. Memanggil itu dengan jalur dari berkas untuk melampirkan dan, secara pilihan, jenis MIME untuk digunakan untuk lampiran. Jika jenis MIME dihilangkan, itu akan ditebak dari nama berkas. Penggunaan sederhana berupa: ``` message.attach_file('/images/weather_map.png') ``` Untuk jenis-jenis MIME dimulai dengan `text/`, data biner ditangani dalam `attach()`. #### Mengirim pilihan lain jenis isi Itu dapat sangat berguna untuk menyertakan banyak versi dari isi dalam sebuah surel; contoh klasik adalah mengirimkan kedua versi teks dan HTML dari pesan. Dengan pustaka surel Django, anda dapat melakukan ini menggunakan kelas `EmailMultiAlternatives`. Subkelas ini dari [`EmailMessage`](#django.core.mail.EmailMessage) mempunyai sebuah metode `attach_alternative()` untuk meneyrtakan versi tambahan dari badan pesan dalam surel. Semua metode lainnya (termasuk pengawalan kelas) diwariskan langsung dari [`EmailMessage`](#django.core.mail.EmailMessage). Untuk mengirim perpaduan teks dan HTML, anda dapat menulis: ``` from django.core.mail import EmailMultiAlternatives subject, from_email, to = 'hello', 'from@example.com', 'to@example.com' text_content = 'This is an important message.' html_content = '

This is an important message.

' msg = EmailMultiAlternatives(subject, text_content, from_email, [to]) msg.attach_alternative(html_content, "text/html") msg.send() ``` Secara awalan, jenis MIME dari parameter `body` dalam sebuah [`EmailMessage`](#django.core.mail.EmailMessage) adalah `"text/plain"`. Itu adalah praktik bagus untuk meninggalkan ini sendiri, karena itu menjamin penerima manapun akan dapat membaca surel, tidak peduli dari surat klien mereka. Bagaimanapun, jika anda sedang percaya diri bahwa penerima anda dapat menangani sebuah jenis isi lain, anda dapat menggunakan atribut `content_subtype` pada kelas [`EmailMessage`](#django.core.mail.EmailMessage) untuk merubah jenis isi utama. Jenis utama akan selalu `"text"`, tetapi anda dapat merubah subjenis. Sebagai contoh: ``` msg = EmailMessage(subject, html_content, from_email, [to]) msg.content_subtype = "html" # Main content is now text/html msg.send() ``` ## Backend email Pengiriman sebenarnya dari sebuah surel ditangani oleh backend email. Kelas backend surel mempunyai metode-metode berikut: - `open()` instantiates a long-lived email-sending connection. - `close()` menutup hubungan mengirim-surel saat ini. - `send_messages(email_messages)` mengirim daftar dari obyek [`EmailMessage`](#django.core.mail.EmailMessage). Jika hubungan tidak terbuka, panggilan ini tidak langsung membuka hubungan, dan menutup hubungan setelah itu. Jika hubungan sudah terbuka, itu akan dibiarkan terbuka setelah surat dikirim. Itu dapat juga digunakan sebagai pengelola konteks, yang akan otomatis memanggil `open()` dan `close()` sesuai kebutuhan: ``` from django.core import mail with mail.get_connection() as connection: mail.EmailMessage( subject1, body1, from1, [to1], connection=connection, ).send() mail.EmailMessage( subject2, body2, from2, [to2], connection=connection, ).send() ``` ### Mengambil sebuah instance dari sebuah backend surel. Fungsi [`get_connection()`](#django.core.mail.get_connection) dalam `django.core.mail` mengembalikan sebuah instance dari backend surel yang anda dapat gunakan. #### `get_connection(backend=None, fail_silently=False, *args, **kwargs)` Secara awalan, sebuah panggilan pada `get_connection()` akan mengembalikan sebuah instance dari backend surel ditentukan dalam [`EMAIL_BACKEND`](/id/2.1/ref/settings/#std-setting-EMAIL_BACKEND). Jika anda menentukan argumen `backend`, sebuah instance dari backend itu akan diinstasiasikan. Argumen `fail_silently` mengendalikan bagaimana backend harus menangani kesalahan. Jika `fail_silently` adalah True, pengecualian selama pengolahan mengirim surel akan secara diam diabaikan. Semua argumen lain dilewatkan langsung ke pembangun dari backend surel. Django dikirim dengan beberapa backend pengiriman surel. Dengan pengecualian dari backend SMTP (yaitu awalan), backend ini hanya berguna selama percobaan dan pengembangan. Jika anda mempunyai persyaratan mengirim surel khusus, anda dapat [write your own email backend](#topic-custom-email-backend). #### Backend SMTP #### `class backends.smtp.EmailBackend(host=None, port=None, username=None, password=None, use_tls=None, fail_silently=False, use_ssl=None, timeout=None, ssl_keyfile=None, ssl_certfile=None, **kwargs)` Ini adalah backend awalan. Surel akan dikirim melalui peladen SMTP. Nilai untuk setiap argumen diambil dari pencocokan pengaturan jika argumen adalah `None`: - `host`: [`EMAIL_HOST`](/id/2.1/ref/settings/#std-setting-EMAIL_HOST) - `port`: [`EMAIL_PORT`](/id/2.1/ref/settings/#std-setting-EMAIL_PORT) - `username`: [`EMAIL_HOST_USER`](/id/2.1/ref/settings/#std-setting-EMAIL_HOST_USER) - `password`: [`EMAIL_HOST_PASSWORD`](/id/2.1/ref/settings/#std-setting-EMAIL_HOST_PASSWORD) - `use_tls`: [`EMAIL_USE_TLS`](/id/2.1/ref/settings/#std-setting-EMAIL_USE_TLS) - `use_ssl`: [`EMAIL_USE_SSL`](/id/2.1/ref/settings/#std-setting-EMAIL_USE_SSL) - `timeout`: [`EMAIL_TIMEOUT`](/id/2.1/ref/settings/#std-setting-EMAIL_TIMEOUT) - `ssl_keyfile`: [`EMAIL_SSL_KEYFILE`](/id/2.1/ref/settings/#std-setting-EMAIL_SSL_KEYFILE) - `ssl_certfile`: [`EMAIL_SSL_CERTFILE`](/id/2.1/ref/settings/#std-setting-EMAIL_SSL_CERTFILE) Backend SMTP adalah konfigurasi awalan diwarisi oleh Django. Jika anda ingin menentukan itu secara jelas, taruh berikut dalam pengaturan anda: ``` EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend' ``` Jika tidak ditentukan, `timeout` awalan akan berupa satu disediakan oleh [`socket.getdefaulttimeout()`](https://docs.python.org/3/library/socket.html#socket.getdefaulttimeout), yang awalan pada `None` (tidak ada waktu habis). #### Backend konsol Daripada mengirim keluar surel asli backend konsol hanya menulis surel yang akan dikirim ke keluaran standar. Secara awalan, backend konsol menulis ke `stdout`. Anda dapat menggunakan obyek aliran-seperti berbeda dengan menyediakan argumen katakunci `stream` ketika membangun hubungan. Untuk menentukan backend ini, taruh berikut dalam pengaturan anda: ``` EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' ``` Backend ini tidak diperuntukkan untuk penggunaan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan. #### Backend berkas Backend berkas menulis surel pada sebuah berkas. Sebuah berkas baru dibuat untuk setiap sesi baru yang terbuka pada backend ini. Direktori dimana berkas-berkas ditulis adalah baik diambil dari pengaturan [`EMAIL_FILE_PATH`](/id/2.1/ref/settings/#std-setting-EMAIL_FILE_PATH) atau dari katakunci `file_path` ketika membuat sebuah hubungan dengan [`get_connection()`](#django.core.mail.get_connection). Untuk menentukan backend ini, taruh berikut dalam pengaturan anda: ``` EMAIL_BACKEND = 'django.core.mail.backends.filebased.EmailBackend' EMAIL_FILE_PATH = '/tmp/app-messages' # change this to a proper location ``` Backend ini tidak diperuntukkan untuk penggunaan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan. #### backend di-memory Backend `'locmem'` menyimpan pesan-pesan dalam atribut khusus dari modul `django.core.mail`. Atribut `outbox` dibuat ketika pesan pertama dikirim. Itu adalah daftar dalam sebuah instance [`EmailMessage`](#django.core.mail.EmailMessage) untuk setiap pesan yang akan dikirim. Untuk menentukan backend ini, taruh berikut dalam pengaturan anda: ``` EMAIL_BACKEND = 'django.core.mail.backends.locmem.EmailBackend' ``` Backend ini tidak dimaksudkan untuk digunakan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan dan percobaan. #### Backend tiruan Ketika nama menganjurkan backend tiruan tidak melakukan apapun dengan pesan-pesan anda. Untuk menentukan backend ini, taruh berikut dalam pengaturan anda: ``` EMAIL_BACKEND = 'django.core.mail.backends.dummy.EmailBackend' ``` Backend ini tidak diperuntukkan untuk penggunaan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan. ### Menentukan penyesuaian backend surel Jika anda butuh merubah bagaimana surel dikirim anda dapat menulis backend surel anda sendiri. Pengaturan [`EMAIL_BACKEND`](/id/2.1/ref/settings/#std-setting-EMAIL_BACKEND) dalam berkas pengaturan anda adalah kemudian Pythn mengimpor jalur untuk kelas backend anda. Backend surel penyesuaian harus subkelas `BaseEmailBackend` yaitu bertempat dalam modul `django.core.mail.backends.base`. Sebuah backend surel penyesuaian harus menerapkan metode `send_messages(email_messages)`. Metode ini menerima daftar dari instance [`EmailMessage`](#django.core.mail.EmailMessage) dan mengembalikan sejumlah dari pesan-pesan terkirim. Jika backend anda mempunyai konsep apapun dari sesi atau hubungan yang gigih, anda harus juga menerapkan metode `open()` dan `close()`. Mengacu pada `smtp.EmailBackend` untuk penerapan acuan. ### Mengirim banyak surel Membangun dan menutup hubungan SMTP (atau hubungan jaringan lain, untuk masalah itu) adalah sebuah pengolahan yang mahal. Jika anda mempunyai banyak surel untuk dikirim, itu masuk akal menggunakan kembali hubungan SMTP, daripada membuat dan manghancurkan hubungan setiap kali anda ingin mengirim surel. Ada dua cara memberitahu sebuah backend surel untuk menggunakan kembali sebuah hubungan. Pertama-tama, anda dapat menggunakan metode `send_messages()`. `send_messages()` mengambil daftar dari instance [`EmailMessage`](#django.core.mail.EmailMessage) (atau subkelas), dan mengirim mereka semua menggunakan hubungan tunggal. Sebagai contoh, jika anda mempunyai sebuah fungsi dipanggil `get_notification_email()` yang mengembalikan daftar dari obyek [`EmailMessage`](#django.core.mail.EmailMessage) mewakili beberapa surel berkala anda ingin kirimkan, anda dapat mengirim surel ini menggunakan panggilan tunggal untuk send\_messages: ``` from django.core import mail connection = mail.get_connection() # Use default email connection messages = get_notification_email() connection.send_messages(messages) ``` Dalam contoh ini, panggilan pada `send_messages()` membuka hubungan pada backend, mengirim daftar pesan-pesan, dan kemudian menutup hubungan kembali. Pendekatan kedua adalah menggunakan metode `open()` dan `close()` pada backend surel untuk secara manual mengendalikan hubungan. `send_messages()` tidak akan secara manual membuka atau menutup hubungan jika itu sudah terbuka, jadi jika anda membuka secara munual hubungan, anda dapat mengendalikan ketika itu tertutup. Sebagai contoh: ``` from django.core import mail connection = mail.get_connection() # Manually open the connection connection.open() # Construct an email message that uses the connection email1 = mail.EmailMessage( 'Hello', 'Body goes here', 'from@example.com', ['to1@example.com'], connection=connection, ) email1.send() # Send the email # Construct two more messages email2 = mail.EmailMessage( 'Hello', 'Body goes here', 'from@example.com', ['to2@example.com'], ) email3 = mail.EmailMessage( 'Hello', 'Body goes here', 'from@example.com', ['to3@example.com'], ) # Send the two emails in a single call - connection.send_messages([email2, email3]) # The connection was already open so send_messages() doesn't close it. # We need to manually close the connection. connection.close() ``` ## Konfigurasi surel untuk pengembangan Ada saatnya ketika anda tidak ingn Django mengirim surel sama sekali. Sebagai contoh, selagi mengembangkan sebuah situs jaringan, anda mungkin tidak ingin mengirim ribuan surel -- tetapi anda mungkin ingin mensahkan surel akan dikirim ke orang benar dibawah suasana yang benar, dan surel itu akan mengandung isi benar. Cara terbaik untuk mengkonfigurasi surel untuk pengembangan lokal adalah menggunakan [console](#topic-email-console-backend) backend surel. Backend ini mengalihkan semua surel ke stdout, mengizinkan anda memeriksa isi dari surel. Backend surel [file](#topic-email-file-backend) dapat berguna selama pengembangan -- backend ini membuang isi dari setiap hubungan SMTP ke sebuah berkas yang dapat diperiksa pada waktu luang anda. Another approach is to use a "dumb" SMTP server that receives the emails locally and displays them to the terminal, but does not actually send anything. Python has a built-in way to accomplish this with a single command: ``` python -m smtpd -n -c DebuggingServer localhost:1025 ``` Perintah ini akan memulai server SMTP sederhana yang berfungsi di port 1025 dari localhost. Server ini berfungsi sesederhana menulis ke standard output semua headers dan badan email. Anda hanya perlu mengubah [`EMAIL_HOST`](/id/2.1/ref/settings/#std-setting-EMAIL_HOST) dan [`EMAIL_PORT`](/id/2.1/ref/settings/#std-setting-EMAIL_PORT) yang sesuai. Untuk diskusi yang lebih detil dari opsi server SMTP, lihat dokumentasi Python untuk modul [`smtpd`](https://docs.python.org/3/library/smtpd.html#module-smtpd). For information about unit-testing the sending of emails in your application, see the [Layanan surel](/id/2.1/topics/testing/tools/#topics-testing-email) section of the testing documentation.